## 10.5. Alphabetical Summary of sed Commands

# | # Begin a comment in a `sed` script. Valid only as the first character of the first line. (Some versions allow comments anywhere, but it is better not to rely on this.) If the first line of the script is `#n`, `sed` behaves as if `-n` had been specified.
: | `:``label` Label a line in the script for 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.
> a | [`address`]`a\` text 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 is 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. #### Example
>     $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.
> b | [`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. #### Example
>     # Ignore tbl tables; resume script after TE:
>     /^\.TS/,/^\.TE/b
> c | [`address1`[`,`address2]]`c\` text Replace (change) the lines selected by the address(es) with text. (See a for details on text.) When a range of lines is specified, all lines as a group are replaced by a single copy of text. The contents of the pattern space are, in effect, deleted and no subsequent editing commands can be applied to the pattern space (or to text). #### Example
>     # Replace first 100 lines in a file:
>     1,100c\
>     \
>     <First 100 names to be supplied>
> d | [`address1`[`,`address2]]`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. #### Example
>     # delete all blank lines:
>     /^$/d
> D | [`address1`[`,`address2]]`D` Delete first part (up to embedded newline) of multiline pattern space created by `N` command and resume editing with first command in script. If this command empties the pattern space, a new line of input is read, as if the `d` command had been executed. #### Example
>     # Strip multiple blank lines, leaving only one:
>     /^$/{
>     N
>     /^\n$/D
>     }
> g | [`address1`[`,`address2]]`g` Paste the contents of the hold space (see h and H) back into the pattern space, wiping out the previous contents of the pattern space. The Example shows a simple way to copy lines. #### Example 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
> G | [`address1`[`,`address2]]`G` Same as `g`, except that a newline and the the hold space are pasted to the end of the pattern space instead of overwriting it. The Example shows a simple way to “cut and paste” lines. #### Example 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
> h | [`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. #### Example
>     # Edit a line; print the change; replay the original
>     /Unix/{
>     h
>     s/.* Unix \(.*\) .*/\1:/
>     p
>     x
>     }
> Sample input:
>     This describes the Unix ls command.
>     This describes the Unix cp command.
> Sample output:
>     ls:
>     This describes the Unix ls command.
>     cp:
>     This describes the Unix cp command.
H | [`address1`[`,`address2]]`H` Append a newline and then the contents of the pattern space 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.
> i | [`address`]`i\` text Insert text before each line matched by address. (See a for details on text.) #### Example
>     /Item 1/i\
>     The five items are listed below:
l | [`address1`[`,`address2]]`l` List the contents of the pattern space, showing nonprinting characters as ASCII codes. Long lines are wrapped.
> n | [`address1`[`,`address2]]`n` Read next line of input into pattern space. The current line 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. #### Example 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
>     }
> N | [`address1`[`,`address2]]`N` Append next input line to contents of pattern space; the new line is separated from the previous contents of the pattern space by a 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. #### Examples Like the Example in n, but print `.NH` line as well as header title:
>     /^\.NH/{
>     N
>     p
>     }
> Join two lines (replace newline with space):
>     /^\.NH/{
>     N
>     s/\n/ /
>     p
>     }
p | [`address1`[`,`address2]]`p` Print the addressed line(s). Note that this can result in duplicate output unless default output is suppressed using `#n` or the `-n` command-line option. Typically used before commands that change flow control (`d`, `n`, `b`) and might prevent the current line from being output. See Examples under h, n, and N.
> P | [`address1`[`,`address2]]`P` Print first part (up to embedded newline) of multiline pattern space created by `N` command. Same as `p` if `N` has not been applied to a line. #### Example Suppose you have function references in two formats:
>     function(arg1, arg2)
>     function(arg1,
>              arg2)
> The following script changes argument `arg2`, regardless of whether it appears on the same line as the function name:
>     s/function(arg1, arg2)/function(arg1, XX)/
>     /function(/{
>     N
>     s/arg2/XX/
>     P
>     D
>     }
> q | [`address`]`q` Quit when address is encountered. The addressed line is first written to the output (if default output is not suppressed), along with any text appended to it by previous `a` or `r` commands. #### Examples Delete everything after the addressed line:
>     /Garbled text follows:/q
> Print only the first 50 lines of a file:
>     50q
> r | [`address`]`r` file Read contents of file and append after the contents of the pattern space. There must be exactly one space between the `r` and the filename. #### Example
>     /The list of items follows:/r item_file
> 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. Any delimiter may be used. Use `\` within pattern or replacement to escape the delimiter. 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, `sed` prints multiple copies of the line. `w` `file` Write the line to file if a replacement was done. A maximum of 10 different files can be opened. n Replace nth instance of pattern on each addressed line. n is any number in the range 1 to 512, and the default is 1. #### 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 and all quotes; print resulting lines:
>     s/://p
>     s/"//gp

>     # Change first "if" but leave "ifdef" alone:
>     /ifdef/!s/if/   if/
> t | [`address1`[`,`address2]]`t` [label] Test if successful substitutions have been made on addressed lines, and if so, branch to the line marked by `:`label (see b and :). If label is not specified, control branches to the bottom of the script. The `t` command is like a case statement in the C programming language or the various shell programming languages. You test each case: when it's true, you exit the construct. #### Example 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):
>     #n
>     /ID/{
>     s/ID: .* Name: .* Rate: .*/&   Phone: ??/p
>     t
>     s/ID: .* Name: .*/&   Rate: ??   Phone: ??/p
>     t
>     s/ID: .*/&   Name: ????   Rate: ??   Phone: ??/p
>     }
> w | [`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 10 different files can be opened in a script. This command creates the file if it does not exist; if the file exists, its contents are overwritten each time the script is executed. Multiple write commands that direct output to the same file append to the end of the file. #### Example
>     # Store tbl and eqn blocks in a file:
>     /^\.TS/,/^\.TE/w troff_stuff
>     /^\.EQ/,/^\.EN/w troff_stuff
x | [`address1`[`,`address2]]`x` Exchange the contents of the pattern space with the contents of the hold space. See h for an example.
> y | [`address1`[`,`address2]]`y/`abc`/`xyz`/` Translate characters. Change every instance of a to x, b to y, c to z, etc. #### Example
>     # Change item 1, 2, 3 to Item A, B, C ...
>     /^item [1-9]/y/i123456789/IABCDEFGHI/

Copyright © 2003 O'Reilly & Associates. All rights reserved.