Using Vi Editor.pptx

Using Vi Editor
Mrs.Harsha V Patil, MIT ACSC Alandi , Pune

What is vi
 The vi editor is elaborated as visual editor. It is installed in every Unix system.
In other words, it is available in all Linux distros. It is user-friendly and works
same on different distros and platforms. It is a very powerful application. An
improved version of vi editor is vim.
The vi editor has two modes:
 Command Mode: In command mode, actions are taken on the file. The vi
editor starts in command mode. Here, the typed words will act as commands in
vi editor. To pass a command, you need to be in command mode.
 Insert Mode: In insert mode, entered text will be inserted into the file.
The Esc key will take you to the command mode from insert mode.
By default, the vi editor starts in command mode. To enter text, you have to be
in insert mode, just type 'i' and you'll be in insert mode. Although, after
typing i nothing will appear on the screen but you'll be in insert mode. Now
you can type anything.
To exit from insert mode press Esc key, you'll be directed to command mode.

If you are not sure which mode you are in, press Esc key twice and you'll be in
command mode.
Using vi
 The vi editor tool is an interactive tool as it displays changes made in the file on
the screen while you edit the file.
 In vi editor you can insert, edit or remove a word as cursor moves throughout
the file.
 Commands are specified for each function like to delete it's x or dd.
 The vi editor is case-sensitive. For example, p allows you to paste after the
current line while P allows you to paste before the current line.
vi syntax: vi <fileName>
In the terminal when you'll type vi command with a file name, the terminal will
get clear and content of the file will be displayed. If there is no such file, then a
new file will be created and once completed file will be saved with the
mentioned file name.

To save and quit
 You can save and quit vi editor from command mode. Before writing save or
quit command you have to press colon (:). Colon allows you to give instructions
to vi.
exit vi table:
Commands Action
:wq Save and quit
:w Save
:q Quit
:w fname Save as fname
ZZ Save and quit
:q! Quit discarding changes made
:w! Save (and write to non-writable file)

 To exit from vi, first ensure that you are in command mode. Now, type
:wq and press enter. It will save and quit vi.
 Type :wq to save and exit the file.
If you want to quit without saving the file, use :q. This command will
only work when you have not made any changes in the file.
Vi Commands
 Linux vi editor is different from other editors. You have to use different
keys to use different functions. Although, it's quite easy and interesting
to use vi editor.
 The vi editor commands are case sensitive.

 To switch from command to insert mode:
Command Action
i Start typing before the current character
I Start typing at the start of current line
a Start typing after the current character
A Start typing at the end of current line
o Start typing on a new line after the current line
O Start typing on a new line before the current line

Commands Action
j To move down
k To move up
h To move left
l To move right
To jump lines:
Commands Action
G Will direct you at the last line of the
file
`` Will direct you to your last position in
the file

To delete:
Commands Action
x Delete the current character
X Delete the character before the
cursor
r Replace the current character
xp Switch two characters
dd Delete the current line
D Delete the current line from current
character to the end of the line
dG delete from the current line to the
end of the file

To repeat and undo:
Commands Action
u Undo the last command
. Repeat the last command
Command to cut, copy and paste:
Commands Action
dd Delete a line
yy (yank yank) copy a line
p Paste after the current line
P Paste before the current line

Start and end of line:
Commands Action
θ Bring at the start of the current
line
^ Bring at the start of the current
line
$ Bring at the end of the current line
dθ Delete till start of a line
d$ Delete till end of a line

Joining lines:
Commands Action
J Join two lines
yyp Repeat the current line
ddp Swap two lines

 Move forward or backward:
Commands Action
w Move one word forward
b Move one word backward
<n>w Move specified number of
words forward
dw Delete one word
yw Copy one word
<n>dw Delete specified number of
words

Search a string:
Commands Action
/string Forward search for given string
?string Backward search for given string
/^string Forward search string at beginning
of a line
/string$ Forward search string at end of a
line
n Go to next occurrence of searched
string
/<he> Search for the word he (and not for
there, here, etc.)
/pl[abc]ce Search for place, plbce, and plcce

3. Merge Redirection:
This allows you to redirect the output of a command or a program to a specific
file descriptor instead of standard output. the syntax for using this is “>&”
operator followed by the file descriptor number.
 “p >& q” Merges output from stream p with stream q
 “p <& q” Merges input from stream p with stream q
Connecting commands: Pipe.
A pipe is a form of redirection (transfer of standard output to some other
destination) that is used in Linux and other Unix-like operating systems to
send the output of one command/program/process to another
command/program/process for further processing.
The Unix/Linux systems allow stdout of a command to be connected to stdin of
another command. You can make it do so by using the pipe character ‘|’. Pipe is
used to combine two or more commands, and in this, the output of one
command acts as input to another command, and this command’s output may
act as input to the next command and so on.

 It can also be visualized as a temporary connection between two or more
commands/ programs/ processes. The command line programs that do the
further processing are referred to as filters.
 This direct connection between commands/ programs/ processes allows them
to operate simultaneously and permits data to be transferred between them
continuously rather than having to pass it through temporary text files or
through the display screen.
 Pipes are unidirectional i.e data flows from left to right through the
pipeline.
 Syntax : command_1 | command_2 | command_3 | .... | command_N
 Example :
1. Listing all files and directories and give it as input to more command.
 $ ls -l | more

Shell Scripts:
 The basic concept of a shell script is a list of commands, which are listed in the
order of execution. A good shell script will have comments, preceded by a
pound sign, #,describing the steps.
 There are conditional tests, such as value A is greater than value B, loops
allowing us to go through massive amounts of data, files to read and store data,
and variables to read and store data, and the script may include functions.
 Shell scripts and functions are both interpreted. This means they are not
compiled.
 It supports less features. It supports input and output redirection operators.
Example Script:
 Assume we create a test.sh script. Note all the scripts would have .sh
extension.
 Before you add anything else to your script, you need to alert the system that a
shell
 script is being started. This is done using the shebang construct.
For example:
#!/bin/sh

This tells the system that the commands that follow are to be executed by the
Bourne shell. It's called a shebang because the # symbol is called a hash, and
the !symbol is called a bang.
 To create a script containing these commands, you put the shebang line first
and then add the commands:
#!/bin/bash
pwd
ls
Shell Comments:
You can put your comments in your script as follows:
#!/bin/bash
# this is sscasc
# Copyright (c)
sscasc.com #
Script follows
here: pwd
ls

Now you save the above content and make this script executable as follows:
$chmod +x test.sh
Now you have your shell script ready to be executed as
follows: $./test.sh
Extended Shell Scripts:
 The shell is, after all, a real programming language, complete with variables,
control structures, and so forth. No matter how complicated a script gets,
however, it is still just a list of commands executed sequentially.
 Following script use the read command which takes the input from the
keyboard and assigns it as the value of the variable PERSON and finally prints
it on STDOUT.
echo "What is your name?"
read PERSON
echo "Hello,$PERSON"

Job ID Versus Process ID
 Background and suspended processes are usually manipulated via job number
(job ID). This number is different from the process ID and is used because it is
shorter.
 In addition, a job can consist of multiple processes running in a series or at the
same time, in parallel. Using the job ID is easier than tracking individual
processes.
Nice command:-
 It is used to change or set the priority of a process
 syntax: $nice-value cat filename
 The default priority of a process in unix is 20
 The value range from 0 to 39, in linux-9 to 20.where 0 is high and 39 is lower
value.
 the default value of reduction is 10.
 The priority of a process can be increased only by administrator using double
minus(--).
 eg:-$nice--15catlast.txt
 The priority of a process can be made lower using the nice command.

Here is sample run of the script:
 $./test.sh
 What is your
 name? vvfgc
 Hello, vvfgc
Variables:
 Variable is value that always changes during execution of a program. It is an
integral part of shell programming. They provide the ability to store and
manipulate information.
 There are 2 types of variables. They are
• Environment variables
• User defined variables

Environment variables:
These variables are the part of the system and these are created and maintained
by the
system itself. These variables always in capital letters only.
Variable meaning
 PS1- this is first prompt setting in Unix ($)
 PS2- this is second prompt setting in Unix (>)
 PATH- whether we are used absolute or relative path.
 HOME- it stores the current root directory.
 LOGNAME-it stores the login name of the user.
User defined variable:
Variables are defined as follows::
variable_name = variable_value

For example:
NAME = "sscasc"
Above example defines the variable NAME and assigns it the value "sscasc".
Variables of this type are called scalar variables. A scalar variable can hold only
one value at a time.
The shell enables you to store any value you want in a variable. For example:
VAR1="ssczsc "
VAR2=100
Accessing Values to variables:
To access the value stored in a variable, prefix its name with the dollar sign ( $):
For example, following script would access the value of defined variable NAME
and would print it on STDOUT:
NAME="vvfgc "
echo $NAME
This would produce following value:
Output: vvfgc

Read-only Variables:
 The shell provides a way to mark variables as read-only by using the “read
only”command. After a variable is marked read-only, its value cannot be
changed.
 For example, following script would give error while trying to change the value
of NAME:
NAME="vvfgc “
readonly NAME
NAME="Qadiri“
This would produce following result:
/bin/sh: NAME: This variable is read only.
Unsetting Variables:
 Unsetting or deleting a variable tells the shell to remove the variable from the
list of variables that it tracks. Once you unset a variable, you would not be able
to access stored value in the variable.

Following is the syntax to unset a defined variable using the unset
command: unset variable_name
Above command would unset the value of a defined variable. Here is a simple
example
NAME="vvfgc"
unset
NAME
echo $NAME
Above example would not print anything. You cannot use the unset command to
unset variables that are marked readonly.

Read command :
This command is used to take the input from the user.
Syntax: $read var1 var2 var3 ….. var n
Syntax: $ read var1
The variable used along with the read command need not be preceded by the
$ symbol.
Ex: clear echo “enter ur name”
read name
echo “hello $name”
Output: enter ur name :vvfgc
Hello vvfgc

Expr command:
This command is used to perform mathematical caluculations.
Syntax: ` expr operand1 operator operand2 `
Where ( ` ) this symbol is known as grep symbol. There is always must a space
between symbol and the expr command.
Ex: clear echo “enter 2 numbers”
read a b
echo “ sum of 2 numbers is ` expr $a + $b ` “
echo “ sub of 2 numbers is ` expr $a - $b ` “
echo “ product of 2 numbers is ` expr $a * $b ` “
echo “ quotient of 2 numbers is ` expr $a /$b ` “
Note: In unix multiplication purpose we use the symbol of “*” because only * is
wild card character.

Test operator [numerical test]
 Arithmetic Operators:
 There are following arithmetic operators supported by
Bourne Shell.
 Assume variable “a” holds 10 and variable “b” holds 20
then:
 Show Examples

Operator Description Example
+ Addition - Adds values on either side of the operator èxpr $a + $b` will give 30
- Subtraction - Subtracts right hand operand from left hand operand èxpr $a -
$b` will give 10
* Multiplication - Multiplies values on either side of the operator èxpr $a * $b`
will give 200/
/ Division - Divides left hand operand by right operand èxpr $b / $a` will give 2
% Modulus - Divides left hand operand by right hand operand and returns
remainder èxpr $b % $a` will give 0
=Assignment - Assign right operand in left a=$b would assign value of b into a
operand
= = Equality - Compares two numbers, if both are [ $a == $b ] would return same
then returns true. false.
!=Not Equality - Compares two numbers, if both [ $a != $b ] would return are
different then returns true. true.

 It is very important to note here that all the conditional expressions would be
put inside
 square braces with one spaces around them, for example [ $a == $b ] is correct
where as
 [$a==$b] is incorrect.
All the arithmetical calculations are done using long integers.
Relational Operators:
 Bourne Shell supports following relational operators which are specific to
numeric values.
 These operators would not work for string values unless their value is numeric.
 For example, following operators would work to check a relation between 10
and 20 as well as in between "10" and "20" but not in between "ten" and
"twenty".
 Assume variable “a” holds 10 and variable “b” holds 20 then:

Operator Description Example:
-eq Checks if the value of two operands is equal or not, if yes then condition
becomes true. [ $a -eq $b ] is not true.
-ne Checks if the value of two operands is equal or not, if values are not equal
then condition becomes true [ $a -ne $b ] is true.
-gt Checks if the value of left operand is greater than the value of right operand, if
yes then condition becomes true. [ $a -gt $b ] is not true.
-lt Checks if the value of left operand is less than the value of right operand, if yes
then condition becomes true.[ $a -lt $b ] is true.
-ge Checks if the value of left operand is greater than or equal to the value of right
operand, if yes then condition becomes true.[ $a -ge $b ] is not true.
-le Checks if the value of left operand is less than or equal to the value of right
operand, if yes then condition becomes true [ $a -le $b ] is true.
 Note here that all the conditional expressions would be put inside square
braces with one spaces around them, for example [ $a <= $b ] is correct where as
[$a <= $b] is incorrect.

 Boolean Operators (or) logical operators:
 There are following Boolean operators supported by
Bourne Shell.
 Assume variable “a” holds 10 and variable “b” holds 20
then:
 Show Examples

! This is logical negation. This inverts a true condition into false and vice versa.[ !
false ] is true.
-o This is logical OR. If one of the operands is true then condition would be true.[
$a -lt 20 - $b -gt 100 ] is true.
-a This is logical AND. If both the operands are true then condition would be true
otherwise it would be false.[ $a -lt 20 -a $b -gt 100 ] is false.
String test Operators
There are following string operators supported by Bourne Shell.
Assume variable a holds "abc" and variable b holds "efg" then:
Show Examples

= Checks if the value of two operands is equal or not, if yes then condition
becomes true. [ $a = $b ] is not true.
!= Checks if the value of two operands is equal or not, if values are not equal then
condition becomes true.[ $a != $b ] is true.
-z Checks if the given string operand size is zero. [ -z $a ] is not true. If it is zero
length then it returns true.
-n Checks if the given string operand size is non- zero. If it is non-zero length
then it returns true. [ -n $a ] is true.
Check if str is not the empty string. If it is str empty then it returns false.[ $a ] is
not false.

File Test Operators
There are following operators to test various properties associated with a Unix
file.
Assume a variable file holds an existing file name "test" whose size is 100
bytes and has read, write and execute permission on:
Show Examples
b file Checks if file is a block special file if yes then condition becomes true. [ -b
$file ] is false.
-c file Checks if file is a character special file if yes then condition becomes true.[
-b $file ] is false.
-d file Check if file is a directory if yes then condition becomes true.[ -d $file ] is
not true.
-f file Check if file is an ordinary file as opposed to a directory or special file if yes
then condition becomes true. [ -f $file ] is true.

-g file Checks if file has its set group ID (SGID) bit set if yes then condition
becomes true. [ -g $file ] is false.
-k file Checks if file has its sticky bit set if yes then condition becomes true. [ -k
$file ] is false.
-p file Checks if file is a named pipe if yes then condition becomes true.[ -p $file ]
is false.
-t file Checks if file descriptor is open and associated
with a terminal if yes then condition becomes true.[ -t $file ]is false.
-u file Checks if file has its set user id (SUID) bit set if yes then condition
becomes true.[ -u $file ] is false.
-r file Checks if file is readable if yes then condition becomes true.[ -r $file ] is
true.
-w file Check if file is writable if yes then condition becomes true.[ -w $file ] is
true.
-x file Check if file is execute if yes then condition becomes true.[ -x $file ] is true.
-s file Check if file has size greater than 0 if yes then condition becomes true.[ -s
$file ] is true.
-e file Check if file exists. Is true even if file is a directory but exists.[ -e $file ] is
true.

Control statements
The ability to control the flow of execution of program is known as control
statements . The different types of control structures are
 Sequence control structure
 Selection control structure
 Looping control structure
Selection control structure
This type of instruction allows the shell script to be executed depending on the
condition. There are mainly 4 types of decision making instructions. They are
 if-then-fi statement
 if-then-else-fi statement
 if-then-elif-then-else-fi statement case-esac statement
if-then-fi statement:
in this first check the condition. That condition is true then only the if block
statements will be executed otherwise the cursor transfer outside the if
condition.

Syntax: ex:
if [ condition ] if [ $a –gt 18 ]
then then
statements echo “eligible for vote”
fi fi
if-then-else-fi statement:
statements will be executed otherwise the else block statements will be executed.
Syntax: ex:
if [ condition ] if [ $a –gt $b ]
then then
statements echo “a is larger than b”
else else
statements echo “b is larger than a”
fi fi

if-then-elif-then-else-fi statement:
statements will be executed otherwise the cursor checks the next condition
then the second condition will be true then inside that statements will be
executed and so on. If any conditions were not true then the else block
statements will be executed.
Syntax: ex:
if [ condition 1 ] if [ $a –gt $b –a $a –gt $c]
then then
statements echo ”a is larger”
elif [ condition 2] elif [ $b –gt $c ]
then then
statements echo “ b is larger”
else else
statements echo “c is larger”
fi fi

Case-esac statement:
Syntax: case $variable in
[match1] )statements ; ;
[match2] statements ; ;
[match3] statements ; ;
: :
: :
*) statements ; ;
esac
here match1,match2 etc are the case labels.
• When a case statement is evaluated the value of variable is matched in any one
of the choices.
• When a match is found then shell executes that corresponding match
statements.
• The pair of semicolon at the end of every choices. It identifies break.
• *) indicates default class. Ex: clear echo “enter a character”

read ch
case $ch in
[a-z]) echo “entered character is lowercase letters” ; ;
[A-Z] echo “entered character is uppercase letters” ; ;
[0-9] echo “entered character isdigit” ; ;
*) echo “invalid choice” ;;
esac
Looping Control statements
In this all statements are executed repeatedly again and again as long as
condition is true.
This is also known as repetition or iteration.
Shell allows various types of looping. They are
• While loop
• Until loop
• For loop

While loop:
 This is the pretested loop or entry controlled loop. In this first check the
condition, if that condition was true then control enter inside the loop
otherwise control transferred outside the loop.
Syntax: ex:
while [ condition ] while [ i –le 10 ]
do do
Statements echo “$i”
done i =` expr $i + 1 `
done

until loop:
 This is also pretested loop or entry controlled loop. In this first check the
condition, if that condition was false then control enter inside the loop
otherwise control transferred outside the loop.
Syntax: ex:
until [ condition ] until [ i -ge 10 ]
do do
Statements echo “$i”
done i =`expr $i + 1 `
done

for loop:
This is a fixed execution loop. This loop is allow to execute list of statements
certain period of time.
Syntax:
for variable in value1 value2 value3….. value n do
statements
done
ex:
for i in 1 2 3 4 5
do
echo $i
i=` expr $i + 1 `
done

Command line arguments.
 The Unix shell is used to run commands, and it allows users to pass run time
arguments to these commands.
 These arguments, also known as command line parameters, that allows the
users to either control the flow of the command or to specify the input data for
the command.
 While running a command, the user can pass a variable number of parameters
in the command line.
 Within the command script, the passed parameters are accessible using
‘positional parameters’. These range from $0 to $9, where $0 refers to the name
of the command itself, and $1 to $9 are the first through to the ninth parameter,
depending on how many parameters were actually passed.
Example:
$ sh hello how to do you do
Here $0 would be assigned sh
$1 would be assigned hello
$2 would be assigned how
And so on …

Some additional commands to process these parameters.
1)Set
This command can be used to set the values of the positional parameters on
the command line.
Example:
$ set how do you do
$ echo $1 $2
how do
Here, “how” was assigned to $1 and “do” was assigned to $2 and so on.
2) shift
This command is used to shift the position of the positional parameters. i.e. $2
will be shifted to $1 all the way to the tenth parameter being shifted to $9. Note
that if in case there are more than 9 parameters, this mechanism can be used to
read beyond the 9th.
Example:
$ set hello good morning how do you do welcome to Unix tutorial.
Here, ‘hello’ is assigned to $1, ‘good’ to $2 and so on to ‘to’ being assigned to
$9. Now the shift command can be used to shift the parameters ‘N’ places.

Example:
$ shift 2
$ echo $1
Now $1 will be ‘morning’ and so on to $8 being ‘unix’ and $9 being ‘tutorial’.
Special Parameters $* and $@
 There are special parameters that allow accessing all the command-line
arguments at once. $* and $@ both will act the same unless they are enclosed
in double quotes, "".
 Both the parameters specify the command-line arguments. However, the "$*"
special parameter takes the entire list as one argument with spaces between
and the "$@" special parameter takes the entire list and separates it into
separate arguments.
 We can write the shell script to process an unknown number of command line
arguments with either the $* or $@ special parameters −

Exit Status
 The $? variable represents the exit status of the previous command.
 Exit status is a numerical value returned by every command upon its
completion. As a rule, most commands return an exit status of 0 if they were
successful, and 1 if they were unsuccessful.
 Some commands return additional exit statuses for particular reasons. For
example, some commands differentiate between kinds of errors and will return
various exit values depending on the specific type of failure.

Thanks !

Using Vi Editor.pptx

More Related Content

Similar to Using Vi Editor.pptx

More from Harsha Patil

Recently uploaded

Using Vi Editor.pptx