Useful Bash Commands.
#!/bin/bash | |
############################################################################## | |
# SHORTCUTS | |
############################################################################## | |
CTRL+A # move to beginning of line | |
CTRL+C # halts the current command | |
CTRL+E # moves to end of line | |
CTRL+K # deletes (kill) forward to end of line | |
CTRL+L # clears screen and redisplay the line | |
CTRL+N # next line in command history | |
CTRL+P # previous line in command history | |
CTRL+R # searches backward | |
CTRL+S # searches forward | |
CTRL+T # transposes two characters | |
CTRL+U # kills backward from point to the beginning of line | |
CTRL+W # kills the word behind the cursor | |
CTRL+X # lists the possible filename completions of the current word | |
CTRL+Y # retrieves (yank) last item killed | |
CTRL+Z # stops the current command, resume with fg in the foreground or bg in the background | |
!! # repeats the last command | |
exit # logs out of current session | |
############################################################################## | |
# SSH, SYSTEM INFO & NETWORK COMMANDS | |
############################################################################## | |
ssh user@host # connects to host as user | |
ssh -p <port> user@host # connects to host on specified port as user | |
ssh-copy-id user@host # adds your ssh key to host for user to enable a keyed or passwordless login | |
whoami # returns your username | |
passwd # lets you change your password | |
date # shows the current date and time | |
cal # shows the month's calendar | |
uptime # shows current uptime | |
w # displays whois online | |
finger <user> # displays information about user | |
uname -a # shows kernel information | |
man <command> # shows the manual for specified command | |
df # shows disk usage | |
du <filename> # shows the disk usage of the files and directories in filename (du -s give only a total) | |
last <yourUsername> # lists your last logins | |
ps -u yourusername # lists your processes | |
kill <PID> # kills the processes with the ID you gave | |
killall <processname> # kill all processes with the name | |
top # displays your currently active processes | |
bg # lists stopped or background jobs ; resume a stopped job in the background | |
fg # brings the most recent job in the foreground | |
fg <job> # brings job to the foreground | |
ping <host> # pings host and outputs results | |
whois <domain> # gets whois information for domain | |
dig <domain> # gets DNS information for domain | |
dig -x <host> # reverses lookup host | |
wget <file> # downloads file | |
curl <file> # downloads file | |
############################################################################## | |
# VARIABLES | |
############################################################################## | |
varname=value # defines a variable | |
varname=value command # defines a variable to be in the environment of a particular subprocess | |
echo $varname # checks a variable's value | |
array[0]=valA # how to define an array | |
array[1]=valB | |
array[2]=valC | |
array=([2]=valC [0]=valA [1]=valB) # another way | |
array=(valA valB valC) # and another | |
${array[i]} # displays array's value for this index. If no index is supplied, array element 0 is assumed | |
${#array[i]} # to find out the length of any element in the array | |
${#array[@]} # to find out how many values there are in the array | |
declare -i d=123 # makes the variables integer | |
declare -r e=456 # makes the variables read-only | |
declare -l f="LOLCats" # convert to lowercase -> lolcats | |
declare -u g="LOLCats" # convert to uppercase -> LOLCATS | |
declare -a # the variables are treaded as arrays | |
declare -f # uses function names only | |
declare -F # displays function names without definitions | |
declare -x # marks the variables for export via the environment | |
${varname:-word} # if varname exists and isn't null, return its value; otherwise return word | |
${varname:=word} # if varname exists and isn't null, return its value; otherwise set it word and then return its value | |
${varname:?message} # if varname exists and isn't null, return its value; otherwise print varname, followed by message and abort the current command or script | |
${varname:+word} # if varname exists and isn't null, return word; otherwise return null | |
${varname:offset:length} # performs substring expansion. It returns the substring of $varname starting at offset and up to length characters | |
${variable#pattern} # if the pattern matches the beginning of the variable's value, delete the shortest part that matches and return the rest | |
${variable##pattern} # if the pattern matches the beginning of the variable's value, delete the longest part that matches and return the rest | |
${variable%pattern} # if the pattern matches the end of the variable's value, delete the shortest part that matches and return the rest | |
${variable%%pattern} # if the pattern matches the end of the variable's value, delete the longest part that matches and return the rest | |
${variable/pattern/string} # the longest match to pattern in variable is replaced by string. Only the first match is replaced | |
${variable//pattern/string} # the longest match to pattern in variable is replaced by string. All matches are replaced | |
${#varname} # returns the length of the value of the variable as a character string | |
*(patternlist) # matches zero or more occurrences of the given patterns | |
+(patternlist) # matches one or more occurrences of the given patterns | |
?(patternlist) # matches zero or one occurrence of the given patterns | |
@(patternlist) # matches exactly one of the given patterns | |
!(patternlist) # matches anything except one of the given patterns | |
$(UNIX command) # command substitution: runs the command and returns standard output | |
############################################################################## | |
# FUNCTIONS | |
############################################################################## | |
# The function refers to passed arguments by position (as if they were positional parameters), that is, $1, $2, and so forth. | |
# $@ is equal to "$1" "$2"... "$N", where N is the number of positional parameters. $# holds the number of positional parameters. | |
function functname() { | |
shell commands | |
} | |
unset -f functname # deletes a function definition | |
declare -f # displays all defined functions in your login session | |
############################################################################## | |
# FLOW CONTROLS | |
############################################################################## | |
statement1 && statement2 # and operator | |
statement1 || statement2 # or operator | |
-a # and operator inside a test conditional expression | |
-o # or operator inside a test conditional expression | |
# STRINGS | |
str1 = str2 # str1 matches str2 | |
str1 != str2 # str1 does not match str2 | |
str1 < str2 # str1 is less than str2 (alphabetically) | |
str1 > str2 # str1 is greater than str2 (alphabetically) | |
-n str1 # str1 is not null (has length greater than 0) | |
-z str1 # str1 is null (has length 0) | |
# FILES | |
-a file # file exists | |
-d file # file exists and is a directory | |
-e file # file exists; same -a | |
-f file # file exists and is a regular file (i.e., not a directory or other special type of file) | |
-r file # you have read permission | |
-s file # file exists and is not empty | |
-w file # your have write permission | |
-x file # you have execute permission on file, or directory search permission if it is a directory | |
-N file # file was modified since it was last read | |
-O file # you own file | |
-G file # file's group ID matches yours (or one of yours, if you are in multiple groups) | |
file1 -nt file2 # file1 is newer than file2 | |
file1 -ot file2 # file1 is older than file2 | |
# NUMBERS | |
-lt # less than | |
-le # less than or equal | |
-eq # equal | |
-ge # greater than or equal | |
-gt # greater than | |
-ne # not equal | |
if condition | |
then | |
statements | |
[elif condition | |
then statements...] | |
[else | |
statements] | |
fi | |
if condition; then | |
statements | |
elif condition; then | |
statements | |
else | |
statements | |
fi | |
# REGEX ======================================== | |
a="This is my string!" | |
if [[ $a= ~[0-9]+ ]]; then | |
echo "There is a number in the string $a" | |
else | |
echo "There is no number in the string $a" | |
fi | |
# ============================================== | |
for x in {1..10} | |
do | |
statements | |
done | |
for name [in list] | |
do | |
statements that can use $name | |
done | |
for (( initialisation ; ending condition ; update )) | |
do | |
statements... | |
done | |
# Examples ======================= | |
# Arrays | |
arr=("apple" "banana" "cherry") | |
for i in ${arr[@]} | |
do | |
echo $i | |
done | |
# Associative array | |
declare -A arr | |
arr=["name"]="Hazz" | |
arr["id"]="1234" | |
for i in "${!arr[@]}" | |
do | |
echo "$i: ${arr[$i]}" | |
done | |
# ================================ | |
case expression in | |
pattern1 ) | |
statements ;; | |
pattern2 ) | |
statements ;; | |
esac | |
# Examples ======================= | |
a="cat" | |
case $a in | |
cat) echo "Meawww";; | |
dog|puppy) echi=o "Bark";; | |
*) echo "No match!";; | |
esac | |
# ================================ | |
select name [in list] | |
do | |
statements that can use $name | |
done | |
while condition; do | |
statements | |
done | |
until condition; do | |
statements | |
done | |
############################################################################## | |
# INPUT/OUTPUT REDIRECTORS | |
############################################################################## | |
cmd1|cmd2 # pipe; takes standard output of cmd1 as standard input to cmd2 | |
< file # takes standard input from file | |
> file # directs standard output to file | |
>> file # directs standard output to file; append to file if it already exists | |
>|file # forces standard output to file even if noclobber is set | |
n>|file # forces output to file from file descriptor n even if noclobber is set | |
<> file # uses file as both standard input and standard output | |
n<>file # uses file as both input and output for file descriptor n | |
n>file # directs file descriptor n to file | |
n<file # takes file descriptor n from file | |
n>>file # directs file description n to file; append to file if it already exists | |
n>& # duplicates standard output to file descriptor n | |
n<& # duplicates standard input from file descriptor n | |
n>&m # file descriptor n is made to be a copy of the output file descriptor | |
n<&m # file descriptor n is made to be a copy of the input file descriptor | |
&>file # directs standard output and standard error to file | |
<&- # closes the standard input | |
>&- # closes the standard output | |
n>&- # closes the ouput from file descriptor n | |
n<&- # closes the input from file descripor n | |
############################################################################## | |
# PROCESS HANDLING | |
############################################################################## | |
# To suspend a job, type CTRL+Z while it is running. You can also suspend a job with CTRL+Y. | |
# This is slightly different from CTRL+Z in that the process is only stopped when it attempts to read input from terminal. | |
# Of course, to interrupt a job, type CTRL+C. | |
myCommand & # runs job in the background and prompts back the shell | |
jobs # lists all jobs (use with -l to see associated PID) | |
fg # brings a background job into the foreground | |
fg %+ # brings most recently invoked background job | |
fg %- # brings second most recently invoked background job | |
fg %N # brings job number N | |
fg %string # brings job whose command begins with string | |
fg %?string # brings job whose command contains string | |
kill -l # returns a list of all signals on the system, by name and number | |
kill PID # terminates process with specified PID | |
ps # prints a line of information about the current running login shell and any processes running under it | |
ps -a # selects all processes with a tty except session leaders | |
trap cmd sig1 sig2 # executes a command when a signal is received by the script | |
trap "" sig1 sig2 # ignores that signals | |
trap - sig1 sig2 # resets the action taken when the signal is received to the default | |
disown <PID|JID> # removes the process from the list of jobs | |
wait # waits until all background jobs have finished | |
############################################################################## | |
# DEBUGGING SHELL PROGRAMS | |
############################################################################## | |
bash -n scriptname # don't run commands; check for syntax errors only | |
set -o noexec # alternative (set option in script) | |
bash -v scriptname # echo commands before running them | |
set -o verbose # alternative (set option in script) | |
bash -x scriptname # echo commands after command-line processing | |
set -o xtrace # alternative (set option in script) | |
trap 'echo $varname' EXIT # useful when you want to print out the values of variables at the point that your script exits | |
function errtrap { | |
es=$? | |
echo "ERROR line $1: Command exited with status $es." | |
} | |
trap 'errtrap $LINENO' ERR # is run whenever a command in the surrounding script or function exits with non-zero status | |
function dbgtrap { | |
echo "badvar is $badvar" | |
} | |
trap dbgtrap DEBUG # causes the trap code to be executed before every statement in a function or script | |
# ...section of code in which the problem occurs... | |
trap - DEBUG # turn off the DEBUG trap | |
function returntrap { | |
echo "A return occurred" | |
} | |
trap returntrap RETURN # is executed each time a shell function or a script executed with the . or source commands finishes executing | |
############################################################################## | |
# GETTING INPUT | |
############################################################################## | |
echo "what's your name?" | |
read name | |
echo "what's your password?" | |
read -s pass | |
# everything on one line | |
read -p "what's your favorite animal" animal | |
echo name: $name, password: $pass, animal: $animal | |
================================================== | |
select animal in "cat" "dog" "bird" "fish" | |
do | |
echo "you selected $animal!" | |
break | |
done | |
================================================== | |
select option in "cat" "dog" "bird" "fish" | |
do | |
case $option in | |
cat) echo "cat like to sleep.";; | |
dog) echo "dogs like to play catch.";; | |
quit) break;; | |
*) echo "I'm not sure what's this?";; | |
esac | |
done |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment