Bash Commands

A regular expression that matches anytime there are 3 consecutive of the same letter

"([a-z])\1{2}" while normally the {2} indicates two copies of whatever pattern, here it appears to indicate two additional copies because the \1 matches the first preceding group and the {2} indicates two copies of the \1, so in total we have the [a-z], and two of \1 which is the same as whatever [a-z] matched to, for a total of three of something a-z can match to. i'm unsure as to how the syntax works, what can be placed in the brackets, why there are quotes, parentheses, and brackets The back-reference '\n', where n is a single nonzero digit, matches the substring previously matched by the nth parenthesized subexpression of the regular expression. For example, '(a)\1' matches 'aa'.

It is also possible to save the output of a command to a variable and the mechanism we use for that is the backtick ( ` ) (Note it is a backtick not a single quote. Typically you'll find the backtick on the keybard to the left of the 1 (one) key.)

#!/bin/bash # A simple demonstration of using backticks # Ryan 30/5/2022 lines=`cat $1 | wc -l` echo The number of lines in the file $1 is $lines

When we run a script, there are several variables that get set automatically for us. Here are some of them: $0 - The name of the script. $1 - $9 - Any command line arguments given to the script. $1 is the first argument, $2 the second and so on. $# - How many command line arguments were given to the script. $* - All of the command line arguments.

#!/bin/bash # A simple demonstration of variables # Ryan 30/5/2022 echo My name is $0 and I have been given $# command line arguments echo Here they are: $* echo And the 2nd command line argument is $2

When we set a variable, we specify it's name, followed directly by an equals sign ( = ) followed directly by the value. (So, no spaces on either side of the = sign.) When we refer to a variable, we must place a dollar sign ( $ ) before the variable name.

#!/bin/bash # A simple demonstration of variables # Ryan 30/5/2022 name='Ryan' echo Hello $name

Some system variables include

$SHELL $PATH

#!/bin/bash #Creates a copies a directory into a new backup one with a date #Nicholas Brown May 30, 2022 currentdate=`date +%F` mkdir $1_$currentdate cp -r $1 $1_$currentdate echo $! has been copied into $1_$currentdate

+ is an option for date, and %F indicates we want the full date with day month and year

When we type a command on the command line, the system runs through a preset series of directories, looking for the program we specified. We may find out these directories by looking at a particular variable PATH The system will look in the first directory and if it finds the program it will run it, if not it will check the second directory and so on. Directories are separated by a colon ( : ). The system will not look in any directories apart from these, it won't even look in your current directory. We can override this behavior however by supplying a path. Bash will then skip $PATH and go straight to the path provided to find the program

./ must be included in the path name to run a script, this is to avoid ambiguity in the event a file is created with the same name as a command

sed stands for Stream Editor and it effectively allows us to do a search and replace on our data. It is quite a powerful command but we will use it here in it's basic format. sed <expression> [path]

A basic expression is of the following format: 's/search/replace/g' The initial s stands for substitute and specifies the action to perform (there are others but for now we'll keep it simple). Then between the first and second slashes ( / ) we place what it is we are searching for. Then between the second and third slashes, what it is we wish to replace it with. The g at the end stands for global and is optional. If we omit it then it will only replace the first instance of search on each line. With the g option we will replace every instance of search that is on each line It's important to note that sed does not identify words but strings of characters. Try running the example above yourself but replacing oranges with es and you'll see what I mean The search term is actually a regex Also note that we included our expression within single quotes. We did this so that any characters included in it which may have a special meaning on the command line don't get interpreted and acted upon by the command line but instead get passed through to sed. control c to get back to the command line if forgetting quotes results in an error

The file system under linux is a hierarchical structure. At the very top of the structure is what's called the root directory. It is denoted by a single slash ( / ).

Absolute paths specify a location (file or directory) in relation to the root directory. You can identify them easily as they always begin with a forward slash ( / ) Relative paths specify a location (file or directory) in relation to where we currently are in the system. They will not begin with a slash.

vim commands

Arrow keys - move the cursor around j, k, h, l - move the cursor down, up, left and right (similar to the arrow keys) ^ (caret) - move cursor to beginning of current line $ - move cursor to end of the current line nG - move to the nth line (eg 5G moves to 5th line) G - move to the last line w - move to the beginning of the next word nw - move forward n word (eg 2w moves two words forwards) b - move to the beginning of the previous word nb - move back n word { - move backward one paragraph } - move forward one paragraph n{ and n} skip n paragraphs n previous regular expression If you type :set nu in edit mode within vi it will enable line numbers. I find that turning line numbers on makes working with files a lot easier.

Wildcards can be used whenever specifying a path on the command line Wildcards may be used at any part of a path.

Because wildcard substitution is done by the system, not the command, they may be used wherever a path is used.

cat projectbackup.sh #!/bin/bash # Backs up a single project directory # Ryan 30/5/2022 if [ $# != 1 ] then echo Usage: A single argument which is the directory to backup exit fi if [ ! -d ~/projects/$1 ] then echo 'The given directory does not seem to exist (possible typo?)' exit fi date=`date +%F` # Do we already have a backup folder for todays date? if [ -d ~/projectbackups/$1_$date ] then echo 'This project has already been backed up today, overwrite?' read answer if [ $answer != 'y' ] then exit fi else mkdir ~/projectbackups/$1_$date fi cp -R ~/projects/$1 ~/projectbackups/$1_$date echo Backup of $1 completed

Exits if there isn't exactly one command line argument Exits if the directory to be copied doesn't exist Checks if there is already a backup if so, asks if it ought to be overridden, if not it makes the directory Copies the directory

r read - you may view the contents of the file. w write - you may change the contents of the file. x execute - you may execute or run the file if it is a program or script.

For every file we define 3 sets of people for whom we may specify permissions. owner - a single person who owns the file. (typically the person who created the file but ownership may be granted to some one else by certain users) group - every file belongs to a single group. others - everyone else who is not in the group or the owner.

If we use the less than operator ( < ) then we can send data the other way. We will read data from the file and feed it into the program via it's STDIN stream.

For example wc -l < sampletexttocountlinesof when we ran wc supplying the file to process as a command line argument, the output from the program included the name of the file that was processed. When we ran it redirecting the contents of the file into wc the file name was not printed. This is because whenever we use redirection or piping, the data is sent anonymously. So in the above example, wc received some content to process, but it has no knowledge of where it came from so it may not print this information

head [number of lines to print] [path]

Head is a program that prints the first so many lines of it's input. By default it will print the first 10 lines but we may modify this with a command line argument.

the bottom left will display "insert" when in insert mode

If you are already in edit mode, pressing Esc does nothing so you won't do any harm.

Any command line arguments we supply for a program must be next to that program. I often find people try and write their pipes all out in one go and make a mistake somewhere along the line. They then think it is in one point but in fact it is another point.

If you build your pipes up incrementally then you won't fall into this trap. Run the first program and make sure it provides the output you were expecting. Then add the second program

cut is a nice little program to use if your content is separated into fields (columns) and you only want certain fields. cut [-options] [path]

In our sample file we have our data in 3 columns, the first is a name, the second is a fruit and the third an amount. Let's say we only wanted the first column. cut -f 1 -d ' ' mysampledata.txt -f allows us to specify which field or fields we would like If we wanted 2 or more fields then we separate them with a comma as below. cut -f 1,2 -d ' ' mysampledata.txt -d changes the delimiter from the default of tab we include the space within single quotes so it knows this is part of the argument

#!/bin/bash If we leave this line out then our Bash script may still work. Most shells (bash included) will assume they are the interpreter if one is not specified.

Later on, you, or someone else, may run your script in conditions under which bash is not the shell currently in use and this could lead to undesireable outcomes.

image1.JPG image2.JPG image3.JPG image4.jpg basename -s .JPG -a *.JPG | xargs -n1 -i mv {}.JPG {}.jpg ls image1.jpg image2.jpg image3.jpg image4.jpg

Line 1 - Run ls to see what the current situation is. Line 4 - Now the magic. it's a little complex so let's break it down again: First we use the command basename. This command allows us to get the name with the suffix removed.T he -s option allows us to specify what the suffix is that should be removed. The -a option allows us to specify multiple files. Basename is one of the few commands that doesn't support multiple files as default. This will give us a listing of the files to be renamed but with the .JPG suffix removed. Now we pipe that list into the command xargs. The first option -n1 specifies that the next command should be executed once for each item passed in through the pipe. -i indicates we are going to use a replacement string in the next command (it defaults to {}). This means, execute the next command, substituting every occurrence of {} with what was just read through the piFinally we specify that the command to execute is mv and fill in the gaps accordingly. Line 6 - We ran ls again just to verify that it did do what we thought it would.

Options can be chained together e.g. -abc would do the same thing as the combination of -a -b and -c

Longhand command line options begin with -- while shorthand command line options have just one - There are a few instance where a particular option requires an argument to go with it and those options generally have to be placed separately. For example: command -a ainfo -bc

Tasks are another term for processes

Many system processes are sleeping while waiting for system input

ZZ (Note: capitals) - Save and exit :q! - discard all changes, since the last save, and exit :w - save file but don't exit :wq - again, save and exit

Most commands within vi are executed as soon as you press a sequence of keys. Any command beginning with a colon ( : ) requires you to hit <enter> to complete the command.

Linux Tutorial

Much of the following was taken from the following website: https://ryanstutorials.net/linuxtutorial/

The same series of permissions may be used for directories but they have a slightly different behaviour. r - you have the ability to read the contents of the directory (ie do an ls) w - you have the ability to write into the directory (ie create files and directories) x - you have the ability to enter that directory (ie cd)

Normally if we give ls an argument which is a directory it will list the contents of that directory. In this case however we are interested in the permissions of the directory directly and the -d option allows us to obtain that. ls -ld will show permissions for a directory

On a Linux system there are only 2 people usually who may change the permissions of a file or directory. The owner of the file or directory and the root user. The root user is a superuser who is allowed to do anything and everything on the system. Typically the administrators of a system would be the only ones who have access to the root account and would use it to maintain the system.

Normally, for optimal security, you should not give either the group or others write access to your home directory, but execute without read can come in handy sometimes. This allows people to get into your home directory but not allow them to see what is there. An example of when this is used is for personal web pages. A common set up is that if you place a directory in your home directory called public_html then the webserver will read and display the contents of it. The webserver runs as a different user to you however so by default will not have access to get in and read those files. This is a situation where it is necessary to grant execute on your home directory so that the webserver user may access the required resources.

Every program we run on the command line automatically has three data streams connected to it. STDIN (0) - Standard input (data fed into the program) STDOUT (1) - Standard output (data printed by the program, defaults to the terminal) STDERR (2) - Standard error (for error messages, also defaults to the terminal) Pretty sure these are all files, because everything in unix/linux are files

Normally, we will get our output on the screen, which is convenient most of the time, but sometimes we may wish to save it into a file to keep as a record, feed into another system, or send to someone else. The greater than operator ( > ) indicates to the command line that we wish the programs output (or whatever it sends to STDOUT) to be saved in a file instead of printed to the screen example ls > filetobecreated if filetobecreated does not already exist it will be created You'll notice that in the above example, the output saved in the file was one file per line instead of all across one line when printed to the screen. The reason for this is that the screen is a known width and the program can format its output to suit that. When we are redirecting, it may be to a file, or it could be somewhere else, so the safest option is to format it as one entry per line to be sure there is room. the file is created first (if it does not exist already) and then the program is run and output saved into the file. If we save into a file which already exists however, then it's contents will be cleared, then the new output saved to it

* - represents zero or more characters ? - represents a single character [] - represents a range of characters

On first glance you may assume that the command above ( ls ) receives the argument b* then proceeds to translate that into the required matches It is actually bash (The program that provides the command line interface) that does the translation for us Bash translates b* into for example sake barry.txt blah.txt bob and then executes the program. The program never sees the wildcards and has no idea that we used them. it means we can use them on the command line whenever we want. Wildcards may be used with any command.

mkdir [options] newdirectoryname

Short for make directory creates a new directory with the name newdirectoryname. The mkdir command treats newdirectoryname as a path -p flag indicates that parent directories should be made as necessary mkdir -p parent1/parent2/directoryiwanttomake makes three directories

tail [-number of lines to print] [path]

Tail is the opposite of head. Tail is a program that prints the last so many lines of it's input. By default it will print the last 10 lines but we may modify this with a command line argument.

I know I've stressed the point but by now hopefully you can appreciate that whenever we refer to a file or directory on the command line it is in fact a path.

The Linux command line does not have an undo feature. Perform destructive actions carefully. Most commands have many useful command line options. Make sure you skim the man page for new commands so you are familiar with what they can do and what is available.

Cron stands for Command Run ON. It is a mechanism that allows you to tell the system to run certain commands at certain times

The file that manages cron is called a crontab. Each user may have their own crontab and within it each line represents a schedule for a particular command as follows: * * * * * command to execute Where the *'s represent (in order from left to right: Minutes (0 - 59) Hours (0 - 23) Day of Month (1 - 31) Months (1 - 12) Day of week (0 - 7) (0 and 7 are Sunday) A * in any of those places means every one of those increments. Some examples: * * * * * /bin/myscript.sh Execute myscript.sh every minute. 30 3 * * 4 /bin/myscript.sh Execute myscript.sh every Thursday at 3:30am. crontab -l provides a list of currently scheduled tasks To edit your scheduled tasks, run the following command. It will open up in your default text editor which is normally Vim. crontab -e

A command line, or terminal, is a text based interface to the system.

The shell is the particular command line interface that is being used. (I think)

vi filename

There are two modes in Vi. Insert (or Input) mode and Edit mode. In input mode you may input or enter content into the file. In edit mode you can move around the file, perform actions such as deleting, copying, search and replace, saving etc press i to enter insert mode esc returns to edit mode

If you accidentally run cat without giving it a command line argument you will notice that the cursor moves to the next line and then nothing happens. Because we didn't specify a file, cat instead reads from something called STDIN (which we'll learn about in the section 'Piping and redirection' which defaults to the keyboard. If you type something then hit <enter> you will see cat mirror your input to the screen. To get out of here you may press <Ctrl> + c which is the universal signal for Cancel in Linux. In fact, whenever you get in trouble you can generally press <Ctrl> + c to get yourself out of trouble.

This command is nice when we have a small file to view but if the file is large then most of the content will fly across the screen and we'll only see the last page of content. For larger files there is a better suited command which is less. less allows you to move up and down within a file using the arrow keys. You may go forward a whole page using the SpaceBar or back a page by pressing b. When you are done you can press q for quit.

whilst you are in the particular manual page you would like to search press forward slash '/' followed by the term you would like to search for and hit 'enter' If the term appears multiple times you may cycle through them by pressing the 'n' button for next.

This search does not appear to work with gitbash

Linux is case sensitive when it comes to file names (this includes the extension in the name if there is one on account of the extension not being treated any differently) This case sensitivity extends to command options as well e.g. ls -a and ls -A are not the same

Unlike windows which is case insensitive

Bash keeps a history of the previously used commands

Use the up and down arrow keys to scroll through the history. Commands in history can be rerun or edited and then rerun rather than typing them out again

We may also reverse a range using the caret ( ^ ) which means look for any character which is not one of the following.

[^a-k]*

echo

a bash command that displays whatever follows it onto the terminal. If it is followed by a variable the terminal displays the value of the variable

Files with names that begin with .

are hidden files Files can be renamed to add or remove a . to add or remove hidden status. Hidden files don't show up in ls, but do show up in ls -a

Tab completion

auto completes if there is only one possibility if not does nothing. If a subsequent tab it will show the possibilities

awk (consider perl for more complicated conditions) It allows you to filter the data and control how it is displayed.

awk '{print $2}' mysampledata.txt awk is the program '{print $2}' is the action to take. We enclose it in single quotes so that none of the characters get interpreted with their special meaning by bash. The curly brackets ( {} ) state that this is an action. It is possible to set conditions outside of these and to have multiple actions depending on conditions. print tells awk to print something and $2 means the second column. mysampledata.txt is the file awk '$3 > 10 {print $1 " - " $2 " : " $3}' mysampledata.txt Prints FirstColumn - SecondColumn : ThirdColumn for rows with the third column having a value greater than 10

cat filename

cat which actually stands for concatenate. It's main purpose is to join files together but in it's most basic form it is useful for just viewing files.

In linux the backslash \ is the escape character

cd \Holiday Photos becomes the same as cd "Holiday Photos" because the \ causes the next special character to be treated as regular text. If a space is introduced as part of a tab autocomplete the terminal will automatically escape those spaces

cd [location]

change directory can take either a relative or an absolute path if used by itself it returns to the root directory

chmod [permissions] path

change mode use + or - to add or revoke privilege u for user g for group o for other x for excecute, r for read w for write example uo+xw gives the user and others the permission to execute write as the owner of a file we can remove our ability to read, write and execute Maybe we have a file with data in it we wish not to accidentally change for instance. While we may remove these permissions, we may not remove our ability to set those permissions

-I flag on xargs allows for substitution and delimits by end lines not by blank space in general

command | xargs -I % command -flags % find -name "file name" | xargs -I {} ls -l {} will treat lines with spaces as ust one thing and perform ls -l on each of them

cp [options] source destination

copies a sourcefile into the location replicafile when copying a file to a path that is also a file the newfile will have the indicated new name, if the destination is a directory, the file will be copied into that directory and the copy will have the same name as the original -r flag stand for recursive and is used to copy a directory and its contents and its content's contents cp -r directory/. newdirectory [would cp -r directory/* newdirectory work as well? (no) Considering hidden files too? (Idk)] to copy only the contents of directory into newdirectory rather than copying directory into newdirectory and having directory's contents be in a subdirectory of newdirectory called directory. It will work regardless of whether or not newdirectory already exists. if a version of the file already exists in the destination it will be overwritten

touch [options] newfilename

creates a new empty file called newfilename

#

denotes that an entire line is a comment

ls -l ~ | grep '^.....w'

displays files for which the group has write permission

file [path]

displays the file type

egrep is a program which will search a given set of data and print every line which contains a given pattern

egrep [command line options] <pattern> [path] It has many command line options which modify it's behaviour so it's worth checking out it's man page. ie the -v option tells grep to instead print every line which does not match the pattern. egrep searches for a string of characters not a word Also note that we included the pattern within quotes. This is not always required but it is safer to get in the habit of always using them. They are required if your pattern contains characters which have a special meaning on the command line. the -n option gives line numbers as well -c gives the number of lines that matched

ls [sv]*

every file whose name either begins with a s or v.

A filter, in the context of the Linux command line, is a program that accepts textual data and then transforms it in a particular way.

filters often have various command line options that will modify their behaviour so it is always good to check out the man page for a filter

we may also include a set by using a hyphen

if we wanted to find every file whose name includes a digit in it we could do the following: ls *[0-9]* * will match with, nothing, that is if the regex starts with a star and the match starts with what comes after the star the match will match

ls [options] [location]

list, displays the contents of the current directory the -l option is for a long listing which includes First character indicates whether it is a normal file ( - ) or directory ( d ) Next 9 characters are permissions for the file or directory (we'll learn more about them in section 6). The next field is the number of blocks (don't worry too much about this). The next field is the owner of the file or directory (ryan in this case). The next field is the group the file or directory belongs to (users in this case). Following this is the file size. Next up is the file modification time. Finally we have the actual name of the file or directory.

Or how about every file with a three letter extension. Note that video.mpeg is not matched as the path name must match the given pattern exactly.

ls *.??? is the period itself a regex symbol? Won't this cause problems

The three streams actually have numbers associated with them (in brackets in the list at the top of the page). STDERR is stream number 2 and we may use these numbers to identify the streams. If we place a number before the > operator then it will redirect that stream (if we don't use a number, like we have been doing so far, then it defaults to stream 1).

ls -l video.mpg blah.foo ls: cannot access blah.foo: No such file or directory -rwxr--r-- 1 ryan users 6 May 16 09:14 video.mpg ls -l video.mpg blah.foo 2> errors.txt -rwxr--r-- 1 ryan users 6 May 16 09:14 video.mpg cat errors.txt ls: cannot access blah.foo: No such file or directory

Maybe we wish to save both normal output and error messages into a single file. This can be done by redirecting the STDERR stream to the STDOUT stream and redirecting STDOUT to a file. We redirect to a file first then redirect the error stream. We identify the redirection to a stream by placing an & in front of the stream number (otherwise it would redirect to a file called 1).

ls -l video.mpg blah.foo > myoutput 2>&1 cat myoutput ls: cannot access blah.foo: No such file or directory -rwxr--r-- 1 ryan users 6 May 16 09:14 video.mpg

Find out the size and modification time of the .bash_history file in every users home directory. (.bash_history is a file in a typical users home directory that keeps a history of commands the user has entered on the command line.

ls -lh /home/*/.bash_history

git bash does not include the man command

man -k [keyword] searches the manual for commands that use a given keyword

the manual provides information about every command, how commands work, and what arguments they take

man commandnamehere gives the manual page for the command comamndnamehere alternatively commadnamehere --help press q to exit the manual

*[[:upper:]]*

matches files containing an uppercase letter

mv [options] source destination

moves files or directories out of their current location and into a new one. A new name can be specified in the destination path for files (idk about directories) if none is specified the former name is retained This can be used to rename a file or directory can take more than 2 arguments moves all but the last into the last

nl stands for number lines and it does just that.

nl [-options] [path] nl -s '. ' -w 10 mysampledata.txt displays mysampledata.txt but places a period after the line number and starts the lines on column 10

command1 | command2

pipe the output of command1 to the input of command2 example ls | head -3 will yield the first three lines of the directory ls | head -3 | tail -1 gives just the third line

ls | head -3 | tail -1 > myoutput

places the third line into file my output

pwd

print working directory, displays the name of the working directory

Linux is extensionless

regardless of file extension in the name, linux will get the file type from the data inside the file

. (dot) - a single character. ? - the preceding character matches 0 or 1 times only. * - the preceding character matches 0 or more times. + - the preceding character matches 1 or more times. {n} - the preceding character matches exactly n times. {n,m} - the preceding character matches at least n times and not more than m times. [agd] - the character is one of those included within the square brackets. [^agd] - the character is not one of those included within the square brackets. [c-f] - the dash within the square brackets operates as a range. In this case it means either the letters c, d, e or f. () - allows us to group several characters to behave as one. | (pipe symbol) - the logical OR operation. ^ - matches the beginning of the line. $ - matches the end of the line.

regex symbols

rmdir [options] directory

remove directory

rm [options] file

removes aka deletes file -r makes the remove recursive and deletes a directory's contents. -i make the removal interactive when combined into -ir gives the option to stop removal before each individual item is removed

cd -

returns to the previous directory

~ . ..

shorthands for ~home directory . current directory .. parent directory

read variable

takes user input and stores it in $variable

In linux everything is a file

text files, directories, keyboard (read only), monitor (write only), all files

ls *.* listed matches from a subdirectory for some reason

the first asterisk CAN match with nothing and the . asterisk a hidden directory, or the whole thing might match a directory might have a name that contains a . ls * will list the current contents, but will also list the contents of subdirectories as the asterisk matches "files" and directories

ls -l

the first ten characters show permissions. If the first is a - then the file is a "file" if it is a d then the file is a directory The following 3 characters represent the permissions for the owner. A letter represents the presence of a permission and a dash ( - ) represents the absence of a permission. The next 3 are for the group and the next and last 3 for others (anyone else)

#!/bin/bash # A simple demonstration of using backticks # Ryan 30/5/2022 lines=`cat $1 | wc -l` echo The number of lines in the file $1 is $lines ./backticks.sh testfile.txt The number of lines in the file testfile.txt is 12

the script will pipe the first argument into the wc command, if $1 is a file its lines will be counted. In the example testfile.txt has 12 lines

If we would like to get a snapshot of what is currently happening on the system we may use a program called top.

top shows running processes Don't worry if a large amount of your memory is used. Linux keeps recently used programs in memory to speed up performance if they are run again. If another process needs that memory, they can easily be cleared to accommodate this.

A lot of commands that involve manipulating data within a file have the nice feature that they will create a file automatically if we refer to it and it does not exist.

touch is actually a command we may use to modify the access and modification times on a file

chmod shorthand

turn for each set of people the desired rwx permissions into binary with 1 for on and 0 for off. Then convert the binary to decimal and concatenate the desired permissions for each set of people. chmod 755 for instance gives the user read write and execute privileges, members of the group and others read and execute permission but not write permission.

wc stands for word count and it does just that (as well as characters and lines). By default it will give a count of all 3 but using command line options we may limit it to just what we are after.

wc [-options] [path] Sometimes you just want one of these values. -l will give us lines only, -w will give us words and -m will give us characters

The very first line of a script should tell the system which interpreter should be used on this file. It is important that this is the very first line of the script. It is also important that there are no spaces. The first two characters #! (the shebang) tell the system that directly after it will be a path to the interpreter to be used. If we don't know where our interpreter is located then we may use a program called which to find out. which <program>

which bash /bin/bash which ls /usr/bin/ls

deletions in vi

x - delete a single character nx - delete n characters (eg 5x deletes five characters) dd - delete the current line dn - d followed by a movement command. Delete to where the movement command would have taken you. (eg d5w means delete 5 words) u - Undo the last action (you may keep pressing u to keep undoing) U (Note: capital) - Undo all changes to the current line