Editor Command Summary

This section is divided into five major parts, describing the commands in the text editors vi, ex, sed, and awk, and the pattern-matching syntax common to all of them.

▪   Pattern-Matching Syntax   ▪

A number of UNIX text-processing programs, including ed, ex, vi, sed, and grep, allow you to perform searches, and in some cases make changes, by searching for text patterns rather than fixed strings. These text patterns (also called regular expressions) are formed by combining normal characters with a number of special characters. The special characters and their use are as follows:

. Matches any single character except newline.
* Matches any number (including zero) of the single character (including a character specified by a regular expression) that immediately precedes it. For example, because . means “any character,” .* means “match any number of any characters.”
[...] Matches any one of the characters enclosed between the brackets. For example, [AB] matches either A or B. A range of consecutive characters can be specified by separating the first and last characters in the range with a hyphen. For example, [A–Z] matches any uppercase letter from A to Z, and [0–9] matches any digit from 0 to 9. If a caret (^) is the first character in the brackets, the comparison is inverted: the pattern will match any characters except those enclosed in the brackets.
\ {n,m\ } Matches a range of occurrences of the single character (including a character specified by a regular expression) that immediately precedes it. n and m are integers between 0 and 256 that specify how many occurrences to match. \{n\} matches exactly n occurrences, \{n,\} matches at least n occurrences, and \{n,m\} matches any number of occurrences between n and m. For example, A\{2,3\} matches either AA (as in AARDVARK) or AAA (as in AAA Travel Agency) but will not match the single letter A. This feature is not supported in all versions of vi.
^ Requires that the following regular expression be found at the beginning of the line.
$ Requires that the preceding regular expression be found at the end of the line.
\ Treats the following special character as an ordinary character. For example, \ . stands for a period and \ * for an asterisk.
\ ( \ ) Saves the pattern enclosed between \ ( and \) in a special holding space. Up to nine patterns can be saved in this way on a single line. They can be “replayed” in substitutions by the escape sequences \1 to \9. This feature is not used in grep and egrep.
\ n Matches the nth pattern previously saved by \ ( and \), where n is a number from 0 to 9 and previously saved patterns are counted from the left on the line. This feature is not used in grep and egrep.

The egrep and awk programs use an extended set of metacharacters:

regexp+ Matches one or more occurrences of the regular expression (regexp).
regexp? Matches zero or one occurrences of the regular expression.
regexp | regexp Matches lines containing either regexp.
(regexp) Used for grouping in complex regular expressions (e.g., with | above).

Regular expressions in ex(: commands from vi) offer some different extensions:

\< Constrains the following pattern to be matched only at the beginning of a word.
\> Constrains the following pattern to be matched only at the end of a word.
\u Appended to the replacement string of a substitute command, converts first character of replacement string to uppercase.
\U Appended to the replacement string of a substitute command, converts entire replacement string to uppercase.
\l Appended to the replacement string of a substitute command, converts first character of replacement string to lowercase.
\L Appended to the replacement string of a substitute command, converts entire replacement string to uppercase.

▪   The vi Editor   ▪

Command-Line Syntax

There are two commands to invoke the vi editor:

vi [options] [file(s)]


view [file(s)]

If a file is not named, vi will open a file that can be given a name with the :f command or when it is saved using the :w command. If more than one file is named, the first file is opened for editing and :n is used to open the next file. The view command opens the first file for read-only use; changes cannot be saved.


l Open file for editing LISP programs
r Recover file
R Open file in read-only mode; same as using view
ttag Start at tag
x Open encrypted file
+ Open file at last line
+ n Open file at line n
+ / pattern Open file at first occurrence of pattern
wn Set window to n lines

Operating Modes

After the file is opened, you are in command mode. From command mode, you can invoke insert mode, issue editing commands, move the cursor to a different position in the file, invoke ex commands or a UNIX shell, and save or exit the current version of the file.

The following commands invoke insert mode:

a A i I o O R s S

While in insert mode, you can enter new text in the file. Press the ESCAPE key to exit insert mode and return to command mode.

Command Syntax

The syntax for editing commands is:

[n] operator [n] object

The commands that position the cursor in the file represent objects that the basic editing operators can take as arguments. Objects represent all characters up to (or back to) the designated object. The cursor movement keys and pattern-matching commands can be used as objects. Some basic editing operators are:

c Change
d Delete
y Yank or copy

If the current line is the object of the operation, then the operator is the same as the object: cc, dd, yy. n is the number of times the operation is performed or the number of objects the operation is performed on. If both n’s are specified, the effect is n times n.

The following text objects are represented:

word Includes characters up to a space or punctuation mark. Capitalized object is variant form that recognizes only blank spaces.
sentence Up to . ! ? followed by two spaces.
paragraph Up to next blank line or paragraph macro defined by para = option.
section Up to next section heading defined by sect = option.


2cw Change the next two words
d} Delete up to the next paragraph
d^ Delete back to the beginning of the line
5yy Copy the next five lines
3dl Delete three characters to the right of the cursor

Status Line Commands

Most commands are not echoed on the screen as you input them. However, the status line at the bottom of the screen is used to echo input for the following commands:

/ ? Start pattern-matching search forward (/) or backwards (?)
: Invoke an ex command
! Invoke a UNIX command that takes as its input an object in the buffer and replaces it with output from the command

Commands that are input on the status line must be entered by pressing the RETURN key. In addition, error messages and output from the ^G command are displayed on the status line.

Summary of vi Commands

. Repeat last command (insert, change, or delete).
^@ Repeat last command.
@buffer Execute command stored in buffer.
  a Append text after cursor.
  A Append text at end of line.
^A Unused.
  b Back up to beginning of word in current line.
  B Back up to word, ignoring punctuation.
^B Scroll backward one window.
  c Change operator.
  C Change to end of current line.
^C Unused.
  d Delete operator.
  D Delete to end of current line.
^D Scroll down half-window.
  e Move to end of word.
  E Move to end of word, ignoring punctuation.
^E Show one more line at bottom of window.
  f Find next character typed forward on current line.
  F Find next character typed back on current line.
^F Scroll forward one window.
  g Unused.
  G Go to specified line or end of file.
^G Print information about file on status line.
  h Left arrow cursor key.
  H Move cursor to home position.
^H Left arrow cursor key; BACKSPACE key in insert mode.
  i Insert text before cursor.
  I Insert text at beginning of line.
^I Unused in command mode; in insert mode, same as TAB key.
  j Down arrow cursor key.
  J Join two lines.
^J Down arrow cursor key.
  k Up arrow cursor key.
  K Unused.
^K Unused.
  l Right arrow cursor key.
  L Move cursor to last position in window.
^L Redraw screen.
  m Mark the current cursor position in register (a-z).
  M Move cursor to middle position in window.
^M Carriage return.
  n Repeat the last search command.
  N Repeat the last search command in reverse direction.
^N Down arrow cursor key.
  o Open line below current line.
  O Open line above current line.
^O Unused.
  p Put yanked or deleted text after or below cursor.
  P Put yanked or deleted text before or above cursor.
^P Up arrow cursor key.
  q Unused.
  Q Quit vi and invoke ex
^Q Unused in command mode; in input mode, quote next character,
  r Replace character at cursor with the next character you type.
  R Replace characters.
^R Redraw the screen,
  s Change the character under the cursor to typed characters.
  S Change entire line.
^S Unused.
  t Move cursor forward to character before next character typed.
  T Move cursor back to character after next character typed.
^T Unused in command mode; in insert mode, used with autoindent option set.
  u Undo the last change made.
  U Restore current line, discarding changes.
^U Scroll the screen upward half-window.
  v Unused.
  V Unused.
^V Unused in command mode; in insert mode, quote next character.
  w Move to beginning of next word.
  W Move to beginning of next word, ignoring punctuation.
^W Unused in command mode; in insert mode, back up to beginning of word.
  x Delete character under the cursor.
  X Delete character before cursor.
^X Unused.
  y Yank or copy operator.
  Y Make copy of current line.
^Y Show one more line at top of window.
  z Redraw the screen, repositioning cursor when followed by CR at the top, . at the middle, and – at the bottom of screen.
  ZZ Exit the editor, saving changes.
^Z Unused.

Characters Not Used in Command Mode

The following characters are unused in command mode and can be mapped as user-defined commands.

^A   g   K ^K
^O   q ^T   v
  V ^W ^X ^Z
  *   \   _ (underscore)

vi set Options

The following options can be specified with the :set command.

Option (Abbreviation) Default Description
autoindent (ai) noai Indents each line to the same level as the line above. Use with shiftwidth option.
autoprint(ap) ap Changes are displayed after each editor command, (For global replacement, last replacement displayed.)
autowrite(aw) noaw Automatically writes (saves) file if changed before opening another file with :n or before giving UNIX command with : !.
beautify (bf) nobf Ignores all control characters during input (except tab, newline, or formfeed).
directory(dir) =tmp Names directory in which ex stores buffer files. (Directory must be writable.)
edcompatible noed-compatible Uses ed-like features on substitute commands.
errorbells(eb) errorbells Error messages ring bell.
hardtabs(ht) -8 Defines boundaries for terminal hardware tabs.
ignorecase(ic) noic Disregards case during a search.
lisp nolisp Indents are inserted in appropriate LISP format. () {} [[ and ]] are modified to have meaning for lisp.
list nolist Tabs print as ^I; ends of lines are marked with $. (Used to tell if end character is a tab or a space.)
magic magic Wildcard characters . * [ are special in patterns.
mesg mesg Permits messages to display on terminal while editing in vi.
number(nu) nonu Displays line numbers on left of screen during editing session.
open open Allows entry to open or visual mode from ex.
optimize(opt) noopt Deletes carriage returns at the end of lines when printing multiple lines; speeds output on dumb terminals when printing lines with leading white space (blanks or tabs).
paragraphs(para) =IPLPPPQP LIpplpipbp Defines paragraph delimiters for movement by { or }. The pairs of characters in the value are the names of nroff/troff macros that begin paragraphs.
prompt prompt Sets ex prompt (:).
readonly(ro) noro Any writes (saves) of a file will fail unless you use ! after the write (works with w, ZZ, or auto write).
redraw(re) noredraw Terminal will redraw the screen whenever edits are made (insert mode pushes over existing characters; deleted lines immediately close up). Default depends on line speed and terminal type, no redraw is useful at slow speeds on a dumb terminal; deleted lines show up @, as and inserted text appears to overwrite existing text until you press ESC.
remap remap Allows nested map sequences.
report = 5 Size of a large edit (i.e., number of lines affected by a single edit) that will trigger a warning message on bottom line of screen.
scroll = [½ window] Amount of screen to scroll.
sections =SHNHH HU Defines section delimiters for { } movement. The pairs of characters in the value are the names of nroff/troff macros that begin sections.
shell(sh) =/bin/sh Pathname of shell used for shell escape (: !) and shell command (: sh). Value is derived from shell environment.
shiftwidth (sw) sw=8 Defines number of spaces to indent when using the ≫ or ≪ commands in the autoindent option.
showmatch(sm) nosm In vi, when ) or } is entered, cursor moves briefly to matching ( or {. (If match is not on the screen, rings the error message bell.) Very useful for programming.
showmode(smd) nosmd (System V, Release 2 vi only). The string Input Mode is printed on the command line whenever input mode is entered.
slowopen(slow) Holds off display during insert. Default depends on line speed and terminal type.
tabstop(ts) = 8 Sets number of spaces that a TAB indents during editing session. (Printer still uses system tab of 8.)
taglength(H) = 0 Defines the number of characters that are significant for tags. Default (zero) means that all characters are significant.
tags =tags/usr/lib/tags Pathname of files containing tags. (See the tag(1) command.) By default, system searches /usr/lib/tags and the file tags in the current directory.
term Terminal type.
terse noterse Displays briefer error messages.
timeout timeout Macros “time out” after 1 second.
ttytype Terminal type.
warn warn Displays No write since last change as warning.
window(w) Shows a certain number of lines of the file on the screen. Default depends on line speed and terminal type.
wrapscan(ws) ws Searches wraparound end of file.
wrapmargin(wm) = 0 Defines right margin. If greater than zero, automatically inserts carriage returns to break lines.
writeany(wa) nowa Allows saving to any file.

▪   The ex Editor   ▪

The ex editor is a line editor that serves as the foundation for the screen editor, vi. All ex commands work on the current line or a range of lines in a file. In vi, ex commands are preceded by a colon and entered by pressing RETURN. In ex itself, the colon is supplied as the prompt at which you enter commands.

The ex editor can also be used on its own. To enter ex from the UNIX prompt:

ex filename

Any of the options described for invoking vi may also be used with ex. In addition, the vi command Q can be used to quit the vi editor and enter ex.

To exit ex:

x Exit, saving changes
q! Quit, without saving changes
vi Enter vi from ex

To enter an ex command from vi:

:address command options

The colon (:) indicates an ex command. The address is a line number or range of lines that are the object of the command.

The following options can be used with commands:

! Indicates a variant form of the command.
parameters Indicates that additional information can be supplied. A parameter can be the name of a file.
count Is the number of times the command is to be repeated.
flag #, p, and l indicate print format.

Unlike vi commands, the count cannot precede the command as it will be taken for the address. d3 deletes three lines beginning with the current line; 3d deletes line 3.

As you type the address and command, it is echoed on the status line. Enter the command by pressing the RETURN key.


If no address is given, the current line is the object of the command. If the address specifies a range of lines, the format is:

x, y

where x and y are the first and last addressed lines. x must precede y in the buffer. x and y may be line numbers or primitives. Using ; instead of , sets the current line to x before interpreting y (that is, the current position willbe at x at the completion of the command).     1,$ addresses all lines in the file.

The following address symbols can be used:

. Current line
n Absolute line number
$ Last line
% All lines, same as 1, $
x− | +n n line before or after x
−[n] One or n lines previous
+ [n] One or n lines ahead
x Line marked with x
′ ′ Previous context
/pat/ or ?pat? Ahead or back to line matching pat

ex Commands

abbrev ab [string text]
Define string when typed to be translated into text. If string and text are not specified, list all current abbreviations.
append [address]a[!]
Append text at specified address, or at present address if none is specified. With the ! flag, toggle the autoindent setting during the input of text.
args ar
Print the members of the argument list, with the current argument printed within brackets ([ ]).
change [address]c[!]
Replace the specified lines with text. With the ! flag, toggle the autoindent setting during the input of text.
copy [address]codestination
Copy the lines included in address to the specified destination address. The command t is a synonym for copy.
delete [address]d[buffer]
Delete the lines included in address. If buffer is specified, save or append the text to the named buffer.
edit e[!] [+n]file
Begin editing on file. If the ! flag is used, do not warn if the present file has not been saved since the last change. If the +n argument is used, begin editing on line n.
file f [filename]
Change the name of the current file to filename, which is considered “not edited.” If no filename is specified, print the current status of the file.
global [address]g[!]/pattern/[commands]
Execute commands on all lines that contain pattern. If commands are not specified, print all such lines. If the ! flag is used, execute commands on all lines not containing pattern.
insert [address]i[!]
Insert text at line before the specified address, or at present address if none is specified. With the ! flag, toggle the autoindent setting during the input of text.
join [address]j[count]
Place the text in the specified range on one line, with white space adjusted to provide two blank characters after a (.), no blank characters if a ) follows, and one blank character otherwise.
k [address]kchar
Mark the given address with char.
list [address]l[count]
Print the specified lines in an unambiguous manner.
map map char commands
Define a macro named char in visual mode with the specified sequence of commands. char may be a single character, or the sequence #n, representing a function key on the keyboard.
mark [address]machar
Mark the specified line with char, a single lowercase letter. Return later to the line with ′x.
move [address]mdestination
Move the lines specified by address to the destination address.
next n[!][[+command] filelist]
Edit the next file in the command-line argument list. Use args for a listing of arguments. If filelist is provided, replace the current argument list with filelist and begin editing on the first file; if command is given (containing no spaces), execute command after editing the first such file.
number [address]nu[count]
Print each line specified by address preceded by its buffer line number. # may be used as an abbreviation for number as well as nu.
open [address]o[/pattern/]
Enter open mode at the lines specified by address, or lines matching pattern. Exit open mode with Q.
preserve pre
Save the current editor buffer as though the system had crashed.
print [address]p[count]
Print the lines specified by address with nonprinting characters printed. P may also be used as an abbreviation.
put [address]pu[char]
Restore previously deleted or yanked lines from named buffer specified by char to the line specified by address; if char is not specified, the last deleted or yanked text is restored.
quit q[!]
Terminate current editing session. If the file was not saved since the last change, or if there are files in the argument list that have not yet be accessed, you will not be able to quit without the ! flag.
read [address]r[!] [file]
Copy the text of file at the specified address. If file is not specified, the current filename is used.
read [address]r !command
Read in the output of command into the text after the line specified by address.
recover rec[file]
Recover file from system save area.
rewind rew[!]
Rewind argument list and begin editing the first file in the list. The ! flag rewinds without warning if the file has not been saved since the last change.
set se parameter parameter2 ...
Set a value to an option with each parameter, or if no parameter is supplied, print all options that have been changed from their defaults. For Boolean-valued options, each parameter can be phrased as option or nooption; other options can be assigned with the syntax, option=value.
shell sh
Create a new shell. Resume editing when the shell is terminated.
source so file
Read and execute commands from file.
substitute [address]s[[/pattern/repl/]options][count]
Replace each instance of pattern on the specified lines with repl. If pattern and repl are omitted, repeat last substitution. The following options are supported:
g Substitute all instances of pattern
c Prompt for confirmation before each change
t [address]tdestination
Copy the lines included in address to the specified destination address.
ta [address]ta tag
Switch the focus of editing to tag.
unabbreviate una word
Remove word from the list of abbreviations.
undo u
Reverse the changes made by the last editing command.
unmap unm char
Remove char from the list of macros.
v [address]v/ pattern /[commands]
Execute commands on all lines not containing pattern. If commands are not specified, print all such lines.
version ve
Print the current version number of the editor and the date the editor was last changed.
visual [address]vi[type][count]
Enter visual mode at the line specified by address. Exit with Q. type is either -, ^ or . (see the z command), count specifies an initial window size.
write [address]w[!] [[≫] file]
Write lines specified by address to file, or full contents of buffer if address is not specified. If file is also omitted, save the contents of the buffer to the current filename. If ≫ file is used, write contents to the end of the specified file. The ! flag forces the editor to write over any current contents of file.
write [address]w !command
Write lines specified by address to command through a pipe.
wq wq[!]
Write and quit the file in one movement.
xit x
Write file if changes have been made to the buffer since last write, then quit.
yank [address]ya[char][count]
Place lines specified by address in named buffer indicated by char. If no char is specified, place in general buffer.
z [address]z[type][count]
Print a window of text with line specified by address at the top, type is as follows:
+ Place specified line at the top of the window (default)
Place specified line at bottom of the window
^ Print the window before the window associated with type –
= Place specified line in the center of the window and leave the current line at this line
count specifies the number of lines to be displayed.
! [address]!command
Execute command in a shell. If address is specified, apply the lines contained in address as standard input to command, and replace the lines with the output.
= [address]=
Print the line number of the line indicated by address.
< > [address]<[count]
or [address] > [count]
Shift lines specified by address in specified direction. Only blanks and tabs are shifted in a left shift (<).
address address
Print the lines specified in address.
Print the next line in the file.
& [address]&[options][count]
Repeat the previous substitute command.
~ [address]~[count]
Replace the previous regular expression with the previous replacement pattern from a substitute command.

▪   The sed Editor   ▪

sed [options] file(s)

The following options are recognized:

n Only print lines specified with the p command, or the p flag of the s command
e cmd Next argument is an editing command
f file Next argument is a file containing editing command

All sed commands have the general form:

    [address][, address][!]command [arguments]

The sed editor copies each line of input into a pattern space. sed instructions consist of addresses and editing commands. If the address of the command matches the line in the pattern space, then the command is applied to that line. If a command has no address, then it is applied to each input line. It is important to note that a command affects the contents of the space; subsequent command addresses attempt to match the line in the pattern space, not the original input line.

Pattern Addressing

In a sed command, an address can either be a line number or a pattern, enclosed in slashes (/pattern/). Address types cannot be mixed when specifying two addresses. Patterns can make use of regular expressions, as described at the beginning of this appendix. Additionally, \n can be used to match any newline in the pattern space (resulting from the N command), but not the newline at the end of the pattern space. If no pattern is specified, command will be applied to all lines. If only one address is specified, the command willbe applied to all lines between the first and second addresses, inclusively. Some commands can only accept one address.

The ! operator following a pattern causes sed to apply the command to all lines that do not contain the pattern.

A series of commands can be grouped after one pattern by enclosing the command list in curly braces:

[/pattern/][, /pattern/]{




Alphabetical List of Commands

: :label
Specify a label to be branched to by b or t. label may contain up to eight characters.
= [/pattern/]=
Write to standard output the line number of each line addressed by pattern.
a [address]a\
Append text following each line matched by address. If text goes over more than one line, newlines must be “hidden” by preceding them with a backslash. The insertion will be terminated by the first newline that is not hidden in this way. The results of this command are read into the pattern space (creating a multiline pattern space) and sent to standard output when the list of editing is finished or a command explicitly prints the pattern space.
b [address1] [, address2]b[label]
Branch to label placed with : command. If no label, branch to the end of the script. That is, skip all subsequent editing commands (up to label) for each addressed line.
c [address1] [, address2]c\
Replace pattern space with text. (See a for details on text.)
d [address1] [, address2]d
Delete line in pattern space. Thus, line is not passed to standard output and a new line of input is read; editing resumes with first command in list.
D [address1] [address2]D
Delete first part (up to embedded newline) of multiline pattern created by N command and begin editing. Same as d if N has not been applied to a line.
g [address1][, address2]q
Copy contents of hold space (see h or H command) into pattern space, wiping out previous contents.
G [address1][, address2]G
Append contents of hold space (see h or H command) to contents of the pattern space.
h [address1][, address2]h
Copy pattern space into hold space, a special buffer. Previous contents of hold space are obliterated.
H [address1][, address2]H
Append pattern space to contents of the hold space. Previous and new contents are separated by a newline.
i [address1]i\
Insert text before each line matched by address. (See a for details on text.)
n [address1][, address2]n
Read next line of input into pattern space. Current line is output but control passes to next editing command instead of beginning at the top of the list.
N [address1][, address2]N
Append next input line to contents of pattern space; the two lines are separated by an embedded newline. (This command is designed to allow pattern matches across two lines.)
p [address1][, address2]p
Print the addressed line(s). Unless the –n command-line option is used, this command will cause duplication of the line in the output. Also used when commands change flow control (d, N, b).
P [address1][, address2]P
Print first part (up to embedded newline) of multiline pattern created by N command. Same as p if N has not been applied to a line.
q [address]q
Quit when address is encountered. The addressed line is first written to output, along with any text appended to it by previous a or r commands.
r [address]r file
Read contents of file and append after the contents of the pattern space. Exactly one space must separate the r and the filename.
s [address1][, address2]s/pattern/replacement/[flags]
Substitute replacement for pattern on each addressed line. If pattern addresses are used, the pattern // represents the last pattern address specified. The following flags can be specified:
g Replace all instances of /pattern/ on each addressed line, not just the first instance.
p Print the line if a successful substitution is done.
If several successful substitutions are done, multiple copies of the line will be printed.
w file Write the line to a file if a replacement was done. A maximum of ten different files can be opened.
t [address1][, address2]t [label]
Test if successful substitutions have been made on addressed lines, and if so, branch to label. (See b and :.) If label is not specified, drop to bottom of list of editing commands.
w [address1][, address2]w file
Write contents of pattern space to file. This action occurs when the command is encountered rather than when the pattern space is output. Exactly one space must separate the w and the filename, A maximum of ten different files can be opened.
x [address1][, address2]x.
Exchange contents of the pattern space with the contents of the hold space.

▪   awk   ▪

An awk program consists of patterns and procedures:

pattern {procedure]

Both are optional. If pattern is missing, {procedure} will be applied to all lines. If {procedure} is missing, the line will be passed unaffected to standard output (i.e., it will be printed as is).

Each input line, or record, is divided into fields by white space (blanks or tabs) or by some other user-definable record separator. Fields are referred to by the variables $1, $2, . . . , $n. $0 refers to the entire record.


Patterns can be specified using regular expressions as described at the beginning of this appendix.

pattern {procedure}

The following additional pattern rules can be used in awk:

images    The special pattern BEGIN allows you to specify procedures that will take place before the first input line is processed. (Generally, you set global variables here.)

images    Interrupt place after the last input line is processed.

images    ^ and $ can be used to refer to the beginning and end of a field, respectively, rather than the beginning and end of a line.

images    A pattern can be a relational expression using any of the operators <, <=, ==, !=, >=, and >. For example, $2 > $1 selects lines for which the second field is greater than the first. Comparisons can be either string or numeric.

images    Patterns can be combined with the Boolean operators || (or), && (and), and ! (not).

images    Patterns can include any of the following predefined variables. For example, NF > 1 selects records with more than one field.

Special Variables

FS Field separator (blank and tab by default)
RS Record separator (newline by default)
OFS Output field separator (blank by default)
ORS Output record separator (newline by default)
NR Number of current record
NF Number of fields in current record
$0 Entire input record
$1, $2, . . . , $n First, second,. . . nth field in current record, where fields are separated by FS


Procedures consist of one or more commands, functions, or variable assignments, separated by newlines or semicolons, and contained within curly braces. Commands fall into four groups:

images    variable or array assignments

images    printing commands

images    built-in functions

images    control flow commands

Variables and Array Assignments

Variables can be assigned a value with an = sign. For example:

FS = “,′′

Expressions using the operators +, , /, and % (modulo) can be assigned to variables.

Arrays can be created with the split function (see following awk commands) or can be simply named in an assignment statement. ++, +=, and −= are used to increment or decrement an array, as in the C language. Array elements can be subscripted with numbers (array[1],. . . ,array[n]) or with names. (For example, to count the number of occurrences of a pattern, you could use the following program:

/pattern/ {n[″/pattern/″]++ }

END {print n[″/pattern/″] }

awk Commands

for (i=lower; i<=upper; i++)
While the value of variable i is in the range between lower and upper, do command. A series of commands must be put within braces. <= or any relational operator can be used; ++ or −− can be used to decrement variable.
for for i in array
For each occurrence of variable i in array, do command. A series of commands must be put inside braces.
if if (condition)
If condition is true, do command(s), otherwise do command in else clause, condition can be an expression using any of the relational operators <, <=, ==, ! =, >=, or >, as well as the pattern-matching operator ~ (e.g., if $1 ~ / [Aa] .*/). A series of commands must be put within braces.
length x = length (arg)
Return the length of arg. If arg is not supplied, $0 is assumed.
log x=log (arg)
Return logarithm of arg.
print print [args]
Print args on output, args is usually one or more fields, but may also be one or more of the predefined variables. Literal strings must be surrounded by quotation marks. Fields are printed in the order they are listed. If separated by commas in the argument list, they are separated in the output by the character specified by OFS. If separated by spaces, they are concatenated in the output.
printf printfformat, “expression(s)
Formatted print statement. Fields or variables can be formatted according to instructions in the format argument. The number of arguments must correspond to the number specified in the format sections.
Format follows the conventions of the C language’s printf statement. Here are a few of the most common formats: a floating point number;
n = total number of digits.
m = number of digits after decimal point.
% [–]nc n specifies minimum field length for format type c. – justifies value in field; otherwise value is right justified.
Format can also contain embedded escape sequences: \n (newline) or \t (tab) are the most common.
Spaces and literal text can be placed in the format argument by surrounding the entire argument with quotation marks. If there are multiple expressions to be printed, you should specify multiple formats. An example is worth a thousand words. For an input file containing only the line:
5 5

The program:

{printf (′′The sum on line %s is %d \n′′, NR, $l+$2) }

will produce:

The sum on line 1 is 10.

followed by a newline.

split x = split (string, array [, sep] )
Split string into elements of array array [1] , . . . , array[n]. string is split at each occurrence of separator sep. If sep is not specified, FS is used. The number of array elements created is returned.
sprintf x = sprintf (“format”, expression)
Return the value of expression(s), using the specified format (see printf).
sqrt x = sqrt(arg)
Return square root of arg.
substr x = substr (string, m, [n] )
Return substring of string beginning at character position m and consisting of the next n characters. If n is omitted, include all characters to the end of string.
while while (condition)
Do command while condition is true (see if for a description of allowable conditions). A series of commands must be put within braces.

Get UNIX° TEXT PROCESSING now with O’Reilly online learning.

O’Reilly members experience live online training, plus books, videos, and digital content from 200+ publishers.