sed - Stream editor
sed [-n] script [file...]
sed [-n] [-e script]... [-f script_file...]... [file...]
The sed utility is a stream editor that reads one or more
text files, makes editing changes according to a script of
editing commands and writes the results to standard output.
Interfaces documented on this reference page conform to
industry standards as follows:
sed: XCU5.0
Refer to the standards(5) reference page for more information
about industry standards and associated tags.
Add the editing commands specified by the string script to
the end of the script of editing commands. If you are
using just one -e option and no -f option, you can omit
the -e option and include the single script on the command
line as an argument to sed. Uses script_file as the
source of the edit script. The script_file is a set of
editing commands to be applied to file. Suppresses all
information normally written to standard output.
The order of presentation of the -e and -f options is significant.
Use the string script as an editing script. See the
description of the -e option. The path name of a file to
be edited. If multiple file operands are specified, all
files are read and concatenated before editing begins.
If no file file operand is specified, standard
input is read.
The sed command includes many features for selecting lines
to be modified and making changes only to the selected
lines.
The sed command uses two work spaces for holding the line
being modified: the pattern space, where the selected
line is held, and the hold space, where a line can be
stored temporarily.
An edit script consists of individual subcommands, each
one on a separate line. The general form of sed subcommands
is as follows: [address_range] function [modifier
...]
The sed command processes each input file by reading an
input line into a pattern space, sequentially applying all
sed subcommands in sequence whose addresses select that
line, and writing the pattern space to standard output.
It then clears the pattern space and repeats this process
for each line in the input file. Some of the subcommands
use a hold space to save all or part of the pattern space
for subsequent retrieval.
[Tru64 UNIX] If you do not specify an argument to the sed
command, the sed usage string is displayed.
When a command includes an address, either a line number
or a search pattern, only the addressed line or lines are
affected by the command. Otherwise, the command is
applied to all lines.
An address is either a decimal line number, a $, which
addresses the last line of input, or a context address. A
context address is a basic regular expression (BRE) as
described for grep, except that you can select the character
delimiter for patterns. The general form of the
expression is as follows: \?pattern?
The ? represents a character delimiter you select. The
backslash (\) is required when you select a delimiter
other than the default slash (/) character. This delimiter
cannot be a 2-byte international character support
extended character.
The default form for the pattern is as follows: /pattern/
In a context address, the construction \cexpressionc,
where c is any character other than a backslash (\) or the
newline character, is identical to /expression/. If the
character designated by c appears following a \ (backslash),
then it is considered to be that literal character,
which does not terminate the RE. For example, in the
context address \xabc\xdefx, the second x stands for
itself, so that the regular expression is abcxdef. The
sequence \n matches a newline character in the pattern
space, except the terminating new line. A dot (.) matches
any character except a terminating newline character.
That is, unlike grep, which cannot match a newline character
in the middle of a line, sed can match a newline character
in the pattern space.
Certain commands allow you to specify one line or a range
of lines to which the command applies. These commands are
called addressed commands. The following rules apply to
addressed commands: A command line with no address selects
every line. A command line with one address, expressed in
context form, selects each line that matches the address.
A command line with two addresses separated by a comma (,)
or semicolon (;) selects the entire range from the first
line that matches the first address through the next line
that matches the second. (If the second address is a number
less than or equal to the line number first selected,
only one line is selected.) Thereafter, the process is
repeated, looking again for the first address.
Subcommands [Toc] [Back]
Backslashes in text are treated like backslashes in the
replacement string of an s command and can be used to protect
initial spaces and tabs against the stripping that is
done on every script line.
The text argument accompanying the a\, c\, and i\ commands
can continue onto more than one line, provided all lines
but the last end with a \ (backslash) to quote the newline
character.
The read_file and write_file arguments must end the command
line and must be preceded by exactly one space. Each
write_file is created before processing begins.
[Tru64 UNIX] The sed command can process up to 999 commands
in a file.
In the following list of subcommands, the maximum number
of permissible addresses for each subcommand is indicated
in parentheses. The sed script subcommands are as follows:
Groups subcommands enclosed in { } (braces). The {
(left brace) can be preceded by spaces and can be followed
by spaces or tabs. The list of subcommands must be separated
by newline characters. The subcommands can also be
preceded by spaces or tabs. The terminating } (right
brace) must be preceded by a newline character and then
zero or more spaces. Places text on the output before
reading the next input line.
The total number of a and/or r subcommands should
not exceed 20. Branches to the : command bearing
the label. If label is empty, it branches to the
end of the script. The labels should not exceed 8
characters in length. Label names should not be
duplicated. The maximum number of labels allowed
in the sed script is 50. Deletes the pattern
space. With a 0 or 1 address or at the end of a
2-address range, places text on the output. Then
it starts the next cycle. Deletes the pattern
space, then starts the next cycle. Deletes the
initial segment of the pattern space through the
first newline character. Then it starts the next
cycle. Replaces the contents of the pattern space
with the contents of the hold space. Appends the
contents of the hold space to the pattern space.
Replaces the contents of the hold space with the
contents of the pattern space. Appends the contents
of the pattern space to the hold space.
Writes text to standard output before reading the
next line into the pattern space. Writes the pattern
space to standard output, showing nonprinting
characters as 3-digit octal values. Long lines are
folded, with the point of folding indicated by
<Backslash><Return>. The end of each line is
marked with a $.
Certain characters are shown as escape sequences as
follows: Backslash Alert Backspace Formfeed Newline
Carriage-return Tab Vertical tab Writes the pattern
space to standard output. It replaces the pattern
space with the next line of input. Appends the
next line of input to the pattern space with an
embedded newline character. (The current line number
changes.) You can use this to search for patterns
that are split onto two lines. Writes the
pattern space to standard output. Writes the initial
segment of the pattern space through the first
newline character to standard output. Branches to
the end of the script. It does not start a new
cycle. Reads the contents of read_file. It places
contents on the output before reading the next
input line.
The total number of a and/or r subcommands should
not exceed 20. Substitutes the replacement string
for the first occurrence of the pattern in the pattern
space. Any character that is entered after
the s command can substitute for the / (slash) separator,
except \ (backslash) and the newline character.
Within the regular expression and replacement
string, the delimiter can appear as a literal
if it is preceded by a \ (backslash).
An & (ampersand) appearing in the replacement
string is replaced by the string matching the RE.
The special meaning of & in this context can be
suppressed by preceding it with a \ (backslash).
The characters \n, where n is a digit, are replaced
by the text matched by the corresponding backreference
expression.
A line can be split by substituting a newline character
into it. You must escape the newline character
in the replacement string by preceding it with
a \ backslash. A substitution is considered to
have been performed even if the replacement string
is identical to the string that it replaces.
You can add zero or more of the following flags:
Where n is 1-512, substitutes replacement for the
nth occurrence of pattern on each addressed line,
rather than for the first occurrence. Substitutes
replacement for all nonoverlapping instances of
pattern on each addressed line, rather than for
just the first one (or for the one specified by n).
Writes the pattern space to standard output if a
replacement was made.
[SVR4] If the environment variable CMD_ENV is set
either to SVR4 or svr4, writes the substituted pattern
space to standard output only once at the end
of the script, unless the -n option is specified.
Writes the pattern space to write_file if a
replacement was made. Appends the pattern space to
write_file. If write_file was not already created
by a previous write by this sed script, sed creates
it. Each write_file is created before processing
begins.
A maximum number of 10 files can be created by sed.
Branches to :label in the script file if any substitutions
were made since the most recent reading
of an input line execution of a t subcommand. If
you do not specify label, control transfers to the
end of the script. Appends the pattern space to
write_file. Exchanges the contents of the pattern
space and the hold space. Replaces all occurrences
of characters in pattern1 with the corresponding
characters from pattern2. The byte lengths of pattern1
and pattern2 must be equal. Applies the
specified sed subcommand only to lines not selected
by the address or addresses. This script entry
simply marks a branch point to be referenced by the
b and t commands. This label can be any sequence
of eight or fewer bytes. Writes the current line
number to standard output as a line. Groups subcommands
enclosed in { } (braces). Ignores an
empty command. If a # (number sign) appears as the
first character on the first line of a script file,
that entire line is treated as a comment, with one
exception. If the character after the # is an n,
the default output is suppressed. The rest of the
line after the #n is ignored. A script must contain
at least one noncomment line.
[Tru64 UNIX] The h subcommand for sed does not work properly.
When you use the h subcommand to place text into
the hold area, only the last line of the specified text is
saved. You can use the H subcommand to append text to the
hold area. The H subcommand and all others dealing with
the hold area work correctly.
The following exit values are returned: Successful completion.
An error occurred.
To perform a global change, enter: sed
"s/happy/enchanted/g" chap1 >chap1.new
This replaces each occurrence of happy found in the
file chap1 with enchanted, and puts the edited version
in a separate file named chap1.new. The g at
the end of the s subcommand tells sed to make as
many substitutions as possible on each line. Without
the g, sed replaces only the first happy on a
line.
The sed stream editor operates as a filter. It
reads text from standard input or from the files
named on the command line (chap1 in this example),
modifies this text, and writes it to standard output.
Unlike most editors, it does not replace the
original file. This makes sed a powerful command
when used in pipelines. To use sed as a filter in
a pipeline (sh only), enter: pr chap2 | sed "s/Page
*[0-9]*$/(&)/" | print
This encloses the page numbers in parentheses
before printing chap2. The pr command puts a heading
and page number at the top of each page, then
sed puts the page numbers in parentheses, and the
print command prints the edited listing.
The sed pattern /Page *[0-9]*$/ matches page numbers
that appear at the end of a line. The s subcommand
changes this to (&), where the & stands for
the pattern that was matched (for example, Page
5). To display selected lines of a file, enter:
sed -n "/food/p" chap3
This displays each line in chap3 that contains the
word food. Normally, sed copies every line to
standard output after it is edited. The -n option
stops sed from doing this. You then use subcommands
like p to write specific parts of the text.
Without the -n, this example displays all the lines
in chap3, and it shows each line containing food
twice. To perform complex editing, enter: sed -f
script.sed chap4 >chap4.new
It is always a good idea to create a sed script
file when you want to do anything complex. You can
then test and modify your script before using it.
You can also reuse your script to edit other files.
Create the script file with an interactive text
editor. A sample sed script follows:
:join /\\$/{N s/\\\n// b join }
This sed script joins each line that ends with a \
(backslash) to the line that follows it. First, the
pattern /\\$/ selects a line that ends with a \ for
the group of commands enclosed in { }. The N subcommand
then appends the next line, embedding a
newline character. The s/\\\n// deletes the \
(backslash) and embedded newline character.
Finally, b join branches back to the label :join to
check for a \ (backslash) at the end of the newly
joined line. Without the branch, sed writes the
joined line and reads the next one before checking
for a second \ character.
The N subcommand causes sed to stop immediately if
there are no more lines of input (that is, if N
reads the End-of-File character). It does not copy
the pattern space to standard output before stopping.
This means that if the last line of the
input ends with a \ (backslash) character, then it
is not copied to the output.
ENVIRONMENT VARIABLES [Toc] [Back] The following environment variables affect the execution
of sed: Provides a default value for the internationalization
variables that are unset or null. If LANG is unset or
null, the corresponding value from the default locale is
used. If any of the internationalization variables contain
an invalid setting, the utility behaves as if none of
the variables had been defined. If set to a non-empty
string value, overrides the values of all the other internationalization
variables. Determines the locale for the
interpretation of sequences of bytes of text data as characters
(for example, single-byte as opposed to multibyte
characters in arguments) and the behavior of character
classes within regular expressions. Determines the locale
for the format and contents of diagnostic messages written
to standard error. Determines the location of message
catalogues for the processing of LC_MESSAGES.
Commands: awk(1), ed(1), grep(1), vi(1)
Standards: standards(5)
Programming Support Tools
sed(1)
[ Back ] |
