The Sed Editor

This section presents the following topics:

• Conceptual overview of sed
• Command-line syntax
• Syntax of sed commands
• Group summary of sed commands
• Alphabetical summary of sed commands
• Examples of Sed Commands

For more information, see the Nutshell Handbook sed & awk.

Command-line Syntax

sed [options] ’command’ file(s) (use double quotes in DOS/Windows)
sed [options] -f scriptfile file(s)

The first form allows you to specify an editing command on the command line, surrounded by single quotes. The second form allows you to specify a scriptfile, a file containing sed commands. If no files are specified, sed reads from standard input.

The following options are recognized:

-n Suppress the default output; sed displays only those lines specified with the p command, or with the p flag of the s command.
-e cmd Next argument is editing command’ not needed unless specifying two or more editing commands.
-f file Next argument is a file containing editing commands.

Conceptual Overview

Sed is a non-interactive, or stream-oriented, editor. It interprets a script and performs the actions in the script. Sed is stream-oriented because, like many UNIX programs, input flows through the program and is directed to standard output. For example, sort is stream-oriented; VI is not. Sed’s input typically comes from a file but can be directed from the keyboard. Output goes to the screen by default but can be captured in a file instead.

Typical Uses of Sed Include:

• Editing one or more files automatically.
• Simplifying repetitive edits to multiple files.
• Writing conversion programs.

• Each line of input is copied into a pattern space.
• All editing commands in a sed script are applied in order to each line of input.
• Editing commands are applied to all lines (globally) unless line addressing restricts the lines affected.
• If a command changes the input, subsequent command-addresses will be applied to the current line in the pattern space, not the original input line.
• The original input file is unchanged because the editing commands modify a copy of the original input line. The copy is sent to standard output (but can be redirected to a file).

Syntax of Sed Commands

Sed commands have the general form:

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

 Sed commands consist of addresses and editing commands. commands consist of a single letter or symbol; they are described later, alphabetically and by group. arguments include the label supplied to b or t, the filename supplied to r or w, and the substitution flags for s. address are described below.

A sed command can specify zero, one, or two addresses. An address can be a line number, the symbol $ (for last line), or a regular expression enclosed in slashes (/pattern/). Regular expressions are described in Section 6. 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.

Examples

Braces ({}) are used in sed to nest one address inside another or to apply multiple commands at the same address.

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

The opening curly brace must end a line, and the closing curly brace must be on a line by itself. Be sure there are no blank spaces after the braces.

Group Summary of Sed Commands

In the Lists below, the sed commands are grouped by function and are described tersely. Full descriptions, including syntax and examples can be found afterward in the alphabetical summary.

Basic Editing

a\ Append text after a line.

c\ Replace text (usually a text block).

i\ Insert text after a line.

d Delete lines.

s Make substitutions.

y Translate characters (like a UNIX tr).

Line Information

= Display line number of a line.

Display control characters in ASCII.

p Display the line.

n Skip the current line and go to line below.

r Read another file's contents into the input.

w Write input lines to another file.

q Quit the sed script (no further output).

h Copy into hold space; wipe out what's there.

H Copy into hold space; append to what's there.

g Get the hold space back; wipe out the destination line.

G Get the hold space back; append on line below.

x Exchange contents of hold space and pattern space.

b Branch to label or to end of script.

t Same as b, but branch only after substitution.

:label Label branched to by t or b.

N Read another line of input (creates embedded newline).

D Delete up to the embedded newline.

P Print up to the embedded newline.

Begin a comment in a sed script. Valid only as the first character of the first line.

:label

Label a line in the script for the transfer of control by b or t. label may contain up to seven characters.

[/pattern/]=

Write to standard output the line number of each line addressed by pattern.

[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 text will be terminated by the first newline that is not hidden in this way. The text is not available in the pattern space, and subsequent commands cannot be applied to it. The results of this command are sent to standard output when the list of editing commands is finished, regardless of what happens to the current line in the pattern space.

$a\
This goes after the last line in the file\
(marked by $). This text is escaped at the \
end of each line, except for the last one.

[address1][,address2]b[label]

Transfer control unconditionally to :label elsewhere in script. That is the command following the label is the next command applied to the current line. If no label is specified, control falls through to the end of the script, so no more commands are applied to the current line.

# Ignore tbl tables; resume script after TE:
/^\.TS/^\.TE/b

[address1][,address2]c\

Replace the lines selected by the address with text. When a range of lines is specified, all lines as a group are replace by a single copy of text. The newline following each line of text must be escaped by a backslash, except the last line. The contents of the pattern space are, in effect, deleted and no subsequent editing commands can be applied to it (or text).

# Replace first 100 lines in a file:
1,100c\
\
<First 100 names to be supplied>

[address1][,addresss2]d

Delete the addressed line (or lines from the pattern space. Thus, the line is not passed to standard output. A new line of input is read, and editing resumes with the first command in the script.

# delete all blank lines:
/^$/d

[address1][,address2]D

Delete first part (up to embedded newline) of multi-line pattern space created by N command and resume editing with the first command in script. If this command empties the pattern space, then a new line of input is read, as if the d had been executed.

# Strip multiple blank lines, leaving only one:
/^$/{
N
/^\n$/D
}

[address1][,address2]g

Paste the contents of the hold space (see h or H command) back into the pattern space, wiping out the previous contents of the pattern space. The example shows a simple way to copy lines.

This script collects all lines containing the word Item: and copies them to a place marker later in the file. The place marker is overwritten.

/Item:/H
/<Replace this line with the item list>/g

[address1][,address2]G

Same as g, except that the hold space is pasted below the address instead of overwriting it. The example shows a simple way to "cut and paste" lines.

This script collects all lines containing the word Item: and moves them after a place marker later in the file. The original Item: lines are deleted.

/Item:/{
H
d
}
/Summary of items:/G

[address1][,address2]h

Copy the pattern space into the hold space, a special temporary buffer. The previous contents of the hold space are obliterated. You can use h to save a line before editing it.

#Edit a line; print the change; replay the original
/UNIX/{
h
s/.* UNIX \(,*\) .*/\1:/
p
x
}

Sample input:

This describes the UNIX 1s command.
This describes the UNIX cp command.

Sample output:

1s
This describes the UNIX 1s command.
cp:
This describes the UNIX cp command.

[address1][,address2]H

Append the contents of the pattern space (preceded by a newline) to the contents of the hold space. Even if the hold space is empty, H still appends a newline. H is like an incremental copy. See examples under g and G.

[address1]i\
text

Insert text before each line matched by address. (See a for details on text.)

/Item 1/i\
The five items are listed below:

[address1[],address2]1

List the contents of the pattern space, showing nonprinting characters as ASCII codes. Long lines are wrapped.

[address1][,address2]n

Read next line of input into pattern space. The current lines is sent to standard output, and the next line becomes the current line. Control passes to the command following n instead of resuming at the top of the script.

In the ms macros, a section header occurs on the line below an .NH macro. To print all lines of header text, invoke this script with sed-n:

/^\.NH/{
n
p
}

[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.) Using \n to match the embedded newline, you can match patterns across multiple lines. See example under D.

Like previous example, but print .NH line as well as header title:

/^\.NH/{
N
p
}

 

Join two lines (replace newline with space):

/^|.NH/{
N
s/\n/ /
p
}

[address1][,address2]p

Print the address lines(s). Unless the -n command-line option is used, this command will cause duplicate lines to be output. Also, it is typically used before commands that change flow control (d, N, b) and that might prevent the current line from being output. See examples under h, n, and N.

[address1][,address2]P

Print first part (up to embedded newline) of multi-line pattern created by n command. Same as p if N has be been applied to a line.

Suppose you have function references in two formats:

function (a,b,c)
function (a,
b,
c)

The following script changes argument c, regardless of whether it appears on the same line as the function name:

S/function(a,b,c)/function(a,b,xx)/
/function(/{
N
S/c/xx/
P

D
}

[address]q

Quit when address is encountered. The addressed line is first written to output (if default output is not suppressed), along with any text appended to it by previous a or r commands.

Delete everything after the addressed line:

/Garbled text follows:/q

Print only the first 50 lines of a file:

50q

[address]r file

Read contents of file and append after the contents of the pattern space. Exactly one space must be put between the r and the filename.

[addres1][,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:

n Replace nth instance of /pattern/ on each addressed line. n is any number in the range 1 to 512; the default is 1.

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. As maximum of 10 different files can be opened.

 

Examples

Here are some short, commented scripts:

 

# Change third and fourth quote to ( and ):
/function/{
s/"/(/3
s/"/)/4
}

# Remove all quotes on a given line:
/Title/s/"//g

# Remove first colon or all quotes; print resulting lines:
s/://p
s/"//gp

# Change first "if" but leave "ifdef" alone:
/ifdef/!s/if/ if/

[address1][,address2]t[label]

Test if any substitutions have been made on addressed line, and if so, branch to line marked by :label. (See b and :.) If label is not specified, control falls through to bottom of script. The t command is like a case statement in the C programming language or the shell programming languages. You test each case: when it's true, you exit the construct.

Suppose you want to fill empty fields of a database. You have this:

ID: 1 Name: greg Rate: 45
ID: 2 Name: dale
ID: 3

You want this:

ID: 1 Name: greg Rate: 45 Phone: ??
ID: 2 Name: dale Rate: ?? Phone: ??
ID: 3 Name: ???? Rate: ?? Phone: ??

You need to test the number of fields already there. Here’s the script (fields are tab-separated):

/ID/{
s/ID: .* Name: .* Rate: .*.& Phone: ??/p
t
s/ID: .* Name: .*/& Rate: ?? Phone: ??/p
t
s/ID: .*/& Name: ?? Rate: ?? Phone: ??/p

[address1][,address2]w file

Append 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 in a script. This command will create the file if it does not exist; if the file exists, its contents will be overwritten each time the script is executed. Multiple write commands that direct output to the same file append to the end of the file.

# Store tbl and eqn blocks in a file:
/^\.TS/,/^\.TE/w troff_stuff
/^\.EQ/,/^\.EN/w troff_stuff

[address1][,address2]x

Exchange contents of the pattern space with the contents of the hold space. See h for an example.

[address1][,address2]y/abc/xyz/

Translate characters. Change every instance of a to x, b to y, i to z, etc.

# Change item 1, 2, 3 to Item A, B, C …
/^item [1-9]/y/i123456789/IABCDEFGHI/

More Examples