全部博文（54）
分类：
2010-11-21 23:36:22
This file documents version 4.2.1 of : Introduction
--- The detailed node listing ---
sed Programs:
Examples:
sed is a stream editor. A stream editor is used to perform basic text transformations on an input stream (a file or input from a pipeline). While in some ways similar to an editor which permits scripted edits (such as ed), sed works by making only one pass over the input(s), and is consequently more efficient. But it is sed's ability to filter text in a pipeline which particularly distinguishes it from other types of editors.
Normally sed is invoked like this:
sed SCRIPT INPUTFILE...
The full format for invoking sed is:
sed OPTIONS... [SCRIPT] [INPUTFILE...]
If you do not specify INPUTFILE, or if INPUTFILE is -, sed filters the contents of the standard input. The script is actually the first non-option parameter, which sed specially considers a script and not an input file if (and only if) none of the other options specifies a script to be executed, that is if neither of the -e and -f options is specified.
sed may be invoked with the following command-line options:
--version--help-n--quiet--silentsed works).
These options disable this automatic printing,
and sed only produces output when explicitly told to
via the p command.
-e script--expression=script-f script-file--file=script-file-i[SUFFIX]--in-place[=SUFFIX]This option implies -s.
When the end of the file is reached, the temporary file is renamed to the output file's original name. The extension, if supplied, is used to modify the name of the old file before renaming the temporary file, thereby making a backup copy).
This rule is followed: if the extension doesn't contain a *,
then it is appended to the end of the current filename as a
suffix; if the extension does contain one or more *
characters, then each asterisk is replaced with the
current filename. This allows you to add a prefix to the
backup file, instead of (or in addition to) a suffix, or
even to place backup copies of the original files into another
directory (provided the directory already exists).
If no extension is supplied, the original file is
overwritten without making a backup.
-l N--line-length=Nl command.
A length of 0 (zero) means to never wrap long lines. If
not specified, it is taken to be 70.
--posixPOSIXLY_CORRECT variable
to a non-empty value.
-b--binary--follow-symlinks-r--regexp-extended-s--separateIf no -e, -f, --expression, or --file options are given on the command-line, then the first non-option argument on the command line is taken to be the script to be executed.
If any command-line parameters remain after processing the above, these parameters are interpreted as the names of input files to be processed. A file name of ‘-’ refers to the standard input stream. The standard input will be processed if no file names are specified.
A sed program consists of one or more sed commands, passed in by one or more of the -e, -f, --expression, and --file options, or the first non-option argument if zero of these options are used. This document will refer to “the” sed script; this is understood to mean the in-order catenation of all of the scripts and script-files passed in.
Commands within a script or script-file can be
separated by semicolons (;) or newlines (ASCII 10).
Some commands, due to their syntax, cannot be followed by semicolons
working as command separators and thus should be terminated
with newlines or be placed at the end of a script or script-file.
Commands can also be preceded with optional non-significant
whitespace characters.
Each sed command consists of an optional address or
address range, followed by a one-character command name
and any additional command-specific code.
sed maintains two data buffers: the active pattern space, and the auxiliary hold space. Both are initially empty.
sed operates by performing the following cycle on each line of input: first, sed reads one line from the input stream, removes any trailing newline, and places it in the pattern space. Then commands are executed; each command can have an address associated to it: addresses are a kind of condition code, and a command is only executed if the condition is verified before the command is to be executed.
When the end of the script is reached, unless the -n option is in use, the contents of pattern space are printed out to the output stream, adding back the trailing newline if it was removed. Then the next cycle starts for the next input line.
Unless special commands (like ‘D’) are used, the pattern space is deleted between two cycles. The hold space, on the other hand, keeps its data between cycles (see commands ‘h’, ‘H’, ‘x’, ‘g’, ‘G’ to move data between both buffers).
Addresses in a sed script can be in any of the following forms:
~step1~2;
to pick every third line starting with the second, ‘2~3’ would be used;
to pick every fifth line starting with the tenth, use ‘10~5’;
and ‘50~0’ is just an obscure way of saying 50.
$/regexp// characters,
each must be escaped by a backslash (\).
The empty regular expression ‘//’ repeats the last regular
expression match (the same holds if the empty regular expression is
passed to the s command). Note that modifiers to regular expressions
are evaluated when the regular expression is compiled, thus it is invalid to
specify them together with the empty regular expression.
\%regexp%% may be replaced by any other single character.)
This also matches the regular expression regexp,
but allows one to use a different delimiter than /.
This is particularly useful if the regexp itself contains
a lot of slashes, since it avoids the tedious escaping of every /.
If regexp itself includes any delimiter characters,
each must be escaped by a backslash (\).
/regexp/I\%regexp%II modifier to regular-expression matching is a The M modifier to regular-expression matching is a An address range can be specified by specifying two addresses
separated by a comma (,). An address range matches lines
starting from where the first address matches, and continues
until the second address matches (inclusively).
If the second address is a regexp, then checking for the ending match will start with the line following the line which matched the first address: a range will always span at least two lines (except of course if the input stream ends).
If the second address is a number less than (or equal to) the line matching the first address, then only the one line is matched.
GNU sed also supports some special two-address forms; all these are GNU extensions:
0,/regexp/0 can be used in an address specification like
0,/regexp/ so that sed will try to match
regexp in the first input line too. In other words,
0,/regexp/ is similar to 1,/regexp/,
except that if addr2 matches the very first line of input the
0,/regexp/ form will consider it to end the range, whereas
the 1,/regexp/ form will match the beginning of its range and
hence make the range span up to the second occurrence of the
regular expression.
Note that this is the only place where the 0 address makes
sense; there is no 0-th line and commands which are given the 0
address in any other way will give an error.
,+N,~NAppending the ! character to the end of an address
specification negates the sense of the match.
That is, if the ! character follows an address range,
then only lines which do not match the address range
will be selected.
This also works for singleton addresses,
and, perhaps perversely, for the null address.
To know how to use sed, people should understand regular expressions (regexp for short). A regular expression is a pattern that is matched against a subject string from left to right. Most characters are ordinary: they stand for themselves in a pattern, and match the corresponding characters in the subject. As a trivial example, the pattern
The quick brown fox
matches a portion of a subject string that is identical to itself. The power of regular expressions comes from the ability to include alternatives and repetitions in the pattern. These are encoded in the pattern by the use of special characters, which do not stand for themselves but instead are interpreted in some special way. Here is a brief description of regular expression syntax as used in sed.
*\, a ., a grouped regexp
(see below), or a bracket expression. As a As *, but matches one or more. It is a As *, but only matches zero or one. It is a Apply postfix operators, like \(abcd\)*:
this will search for zero or more whole sequences
of ‘abcd’, while abcd* would search
for ‘abc’ followed by zero or more occurrences
of ‘d’. Note that support for \(abcd\)* is
required by POSIX 1003.1-2001, but many non-GNU
implementations do not support it and hence it is not universally
portable.
.^In most scripts, pattern space is initialized to the content of each
line (see How sed works). So, it is a
useful simplification to think of ^#include as matching only
lines where ‘#include’ is the first thing on line—if there are
spaces before, for example, the match fails. This simplification is
valid as long as the original content of pattern space is not modified,
for example with an s command.
^ acts as a special character only at the beginning of the
regular expression or subexpression (that is, after \( or
\|). Portable scripts should avoid ^ at the beginning of
a subexpression, though, as The characters $, *, ., [, and \
are normally not special within list. For example, [\*]
matches either ‘\’ or ‘*’, because the \ is not
special here. However, strings like [.ch.], [=a=], and
[:space:] are special within list and represent collating
symbols, equivalence classes, and character classes, respectively, and
[ is therefore special within list when it is followed by
., =, or :. Also, when not in
POSIXLY_CORRECT mode, special escapes like \n and
\t are recognized within list. See .
\|regexp2\|, ^, and
$, but less tightly than the other regular expression
operators.
\digit\(...\) parenthesized
subexpression in the regular expression. This is called a back
reference. Subexpressions are implicity numbered by counting
occurrences of \( left-to-right.
\n\char$,
*, ., [, \, or ^.
Note that the only C-like
backslash sequences that you can portably assume to be
interpreted are \n and \\; in particular
\t is not portable, and matches a ‘t’ under most
implementations of sed, rather than a tab character.
Note that the regular expression matcher is greedy, i.e., matches are attempted from left to right and, if two or more matches are possible starting at the same character, it selects the longest.
Examples:
If you use sed at all, you will quite likely want to know these commands.
#The # character begins a comment;
the comment continues until the next newline.
If you are concerned about portability, be aware that
some implementations of sed (which are not posix
conformant) may only support a single one-line comment,
and then only when the very first character of the script is a #.
Warning: if the first two characters of the sed script
are #n, then the -n (no-autoprint) option is forced.
If you want to put a comment in the first line of your script
and that comment begins with the letter ‘n’
and you do not want this behavior,
then be sure to either use a capital ‘N’,
or place at least one space before the ‘n’.
q [exit-code]Exit sed without processing any more commands or input.
Note that the current pattern space is printed if auto-print is
not disabled with the -n options. The ability to return
an exit code from the sed script is a Delete the pattern space;
immediately start next cycle.
pn{ commands }{ and } characters.
This is particularly useful when you want a group of commands
to be triggered by a single address (or address-range) match.
s CommandThe syntax of the s (as in substitute) command is
‘s/regexp/replacement/flags’. The /
characters may be uniformly replaced by any other single
character within any given s command. The /
character (or whatever other character is used in its stead)
can appear in the regexp or replacement
only if it is preceded by a \ character.
The s command is probably the most important in sed
and has a lot of different options. Its basic concept is simple:
the s command attempts to match the pattern
space against the supplied regexp; if the match is
successful, then that portion of the pattern
space which was matched is replaced with replacement.
The replacement can contain \n (n being
a number from 1 to 9, inclusive) references, which refer to
the portion of the match which is contained between the nth
\( and its matching \).
Also, the replacement can contain unescaped &
characters which reference the whole matched portion
of the pattern space.
Finally, as a The s command can be followed by zero or more of the
following flags:
gNote: the posix standard does not specify what should happen
when you mix the g and number modifiers,
and currently there is no widely agreed upon meaning
across sed implementations.
For If the substitution was made, then print the new pattern space.
Note: when both the p and e options are specified,
the relative ordering of the two produces very different results.
In general, ep (evaluate then print) is what you want,
but operating the other way round can be useful for debugging.
For this reason, the current version of GNU sed interprets
specially the presence of p options both before and after
e, printing the pattern space before and after evaluation,
while in general flags for the s command show their
effect just once. This behavior, although documented, might
change in future versions.
w file-nameeI modifier to regular-expression matching is a The M modifier to regular-expression matching is a
Next: ,
Previous: ,
Up:
Though perhaps less frequently used than those in the previous section, some very small yet useful sed scripts can be built with these commands.
y/source-chars/dest-chars// characters may be uniformly replaced by
any other single character within any given y command.)
Transliterate any characters in the pattern space which match any of the source-chars with the corresponding character in dest-chars.
Instances of the / (or whatever other character is used in its stead),
\, or newlines can appear in the source-chars or dest-chars
lists, provide that each instance is escaped by a \.
The source-chars and dest-chars lists must
contain the same number of characters (after de-escaping).
a\\,
which are removed from the output)
to be output at the end of the current cycle,
or when the next input line is read.
Escape sequences in text are processed, so you should
use \\ in text to print a single backslash.
As a As a Immediately output the lines of text which follow this command
(each but the last ending with a \,
which are removed from the output).
c\\,
which are removed from the output)
in place of the last line
(or in place of each line, if no addresses were specified).
A new cycle is started after this command is done,
since the pattern space will have been deleted.
=l n\ character)
are printed in C-style escaped form; long lines are split,
with a trailing \ character to indicate the split;
the end of each line is marked with a $.
n specifies the desired line-wrap length; a length of 0 (zero) means to never wrap long lines. If omitted, the default as specified on the command line is used. The n parameter is a As a Queue the contents of filename to be read and inserted into the output stream at the end of the current cycle, or when the next input line is read. Note that if filename cannot be read, it is treated as if it were an empty file, without any error indication.
As a GNU sed extension, the special value /dev/stdin
is supported for the file name, which reads the contents of the
standard input.
w filenameThe file will be created (or truncated) before the first input line is
read; all w commands (including instances of the