sed(1) 맨 페이지 - 윈디하나의 솔라나라

개요

섹션
맨 페이지 이름
검색(S)

sed(1)

sed(1)                           User Commands                          sed(1)



NAME
       sed - stream editor

SYNOPSIS
       /usr/bin/sed [-n] script [file]...


       /usr/bin/sed [-n] [-e script]... [-f script_file]... [file]...


       /usr/xpg4/bin/sed [-n] script [file]...


       /usr/xpg4/bin/sed [-n] [-e script]... [-f script_file]... [file]...

DESCRIPTION
       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. The script is obtained from
       either the script operand string, or a combination of the  option-argu‐
       ments from the -e  script and -f  script_file options.


       The  sed utility is a text editor. It cannot edit binary files or files
       containing ASCII NUL (\0) characters or very long lines.

OPTIONS
       The following options are supported:

       -e script         script is an edit command for sed.  See  USAGE  below
                         for  more  information  on  the  format of script. If
                         there is just one -e option and no  -f  options,  the
                         flag -e may be omitted.


       -f script_file    Takes  the  script from script_file. script_file con‐
                         sists of editing commands, one per line.


       -n                Suppresses the default output.



       Multiple -e and -f options may be specified. All commands are added  to
       the script in the order specified, regardless of their origin.

OPERANDS
       The following operands are supported:

       file      A path name of a file whose contents will be read and edited.
                 If multiple file operands are specified, the named files will
                 be  read in the order specified and the concatenation will be
                 edited. If no file operands are specified, the standard input
                 will be used.


       script    A  string  to  be used as the script of editing commands. The
                 application must not  present  a  script  that  violates  the
                 restrictions  of a text file, except that the final character
                 need not be a NEWLINE character.


USAGE
       A script consists of editing commands, one per line, of  the  following
       form:


       [ address [ , address ] ] command [ arguments ]


       Zero or more blank characters are accepted before the first address and
       before command. Any number of semicolons are accepted before the  first
       address.


       In  normal  operation,  sed cyclically copies a line of input (less its
       terminating NEWLINE character) into a pattern space  (unless  there  is
       something  left  after  a  D command), applies in sequence all commands
       whose addresses select that pattern space,  and  copies  the  resulting
       pattern  space to the standard output (except under -n) and deletes the
       pattern space. Whenever the pattern space is written to standard output
       or  a named file, sed will immediately follow it with a NEWLINE charac‐
       ter.


       Some of the commands use a hold space to save all or part of  the  pat‐
       tern  space  for subsequent retrieval. The pattern and hold spaces will
       each be able to hold at least 8192 bytes.

   sed Addresses
       An address is either empty, a decimal number that  counts  input  lines
       cumulatively  across  files, a $ that addresses the last line of input,
       or a context address, which  consists  of  a  /regular  expression/  as
       described on the regexp(7) manual page.


       A command line with no addresses selects every pattern space.


       A command line with one address selects each pattern space that matches
       the address.


       A command line with two addresses selects the inclusive range from  the
       first  pattern  space  that  matches the first address through the next
       pattern space that matches the second address. Thereafter  the  process
       is  repeated,  looking  again  for  the  first  address. (If the second
       address is a number less than or equal to the line number  selected  by
       the  first address, only the line corresponding to the first address is
       selected.)


       Typically, address are separated from each other by a comma  (,).  They
       may also be separated by a semicolon (;).

   sed Regular Expressions
       sed  supports  the basic regular expressions described on the regexp(7)
       manual page, with the following additions:

       \cREc     In a context address, the construction \cREc, where c is  any
                 character  other  than  a  backslash or NEWLINE character, is
                 identical to /RE/. If the character designated by  c  appears
                 following  a backslash, then it is considered to be that lit‐
                 eral 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.


       \n        The escape sequence \n matches a NEWLINE  character  embedded
                 in the pattern space. A literal NEWLINE character must not be
                 used in the regular expression of a context address or in the
                 substitute command.



       Editing  commands can be applied only to non-selected pattern spaces by
       use of the negation command ! (described below).

   sed Editing Commands
       In the following list of functions the maximum  number  of  permissible
       addresses for each function is indicated.


       The r and w commands take an optional rfile (or wfile) parameter, sepa‐
       rated from the command letter by one or more blank characters.


       Multiple commands can be specified by separating them with a  semicolon
       (;) on the same command line.


       The  text  argument  consists of one or more lines, all but the last of
       which end with \ to hide the NEWLINE. Each embedded  NEWLINE  character
       in  the text must be preceded by a backslash. Other backslashes in text
       are removed and the following character  is  treated  literally.  Back‐
       slashes  in text are treated like backslashes in the replacement string
       of an s command, and may be used to protect  initial  blanks  and  tabs
       against  the  stripping that is done on every script line. The rfile or
       wfile argument must terminate the command line and must be preceded  by
       exactly  one  blank. The use of the wfile parameter causes that file to
       be initially created, if it does not exist, or will  replace  the  con‐
       tents of an existing file. There can be at most 10 distinct wfile argu‐
       ments.


       Regular expressions match entire strings, not  just  individual  lines,
       but a NEWLINE character is matched by \n in a sed RE. A NEWLINE charac‐
       ter is not allowed in an RE. Also notice that  \n  cannot  be  used  to
       match  a NEWLINE character at the end of an input line; NEWLINE charac‐
       ters appear in the pattern space as a result of the N editing command.


       Two of the commands take a command-list, which is a list  of  sed  com‐
       mands separated by NEWLINE characters, as follows:

         { command
         command
         }



       The  {  can  be preceded with blank characters and can be followed with
       white space. The commands can be preceded by white space. The terminat‐
       ing  }  must  be preceded by a NEWLINE character and can be preceded or
       followed by <blank>s.  The  braces  may  be  preceded  or  followed  by
       <blank>s.  The command may be preceded by <blank>s, but may not be fol‐
       lowed by <blank>s.


       The following table lists the functions, with  the  maximum  number  of
       permissible addresses.


       tab()   box;   cw(0.92i)  |cw(1.38i)  |cw(3.21i)  cw(0.92i)  |lw(1.38i)
       |lw(3.21i) Max AddressCommandDescription _ 1a\  textT{ Append  by  exe‐
       cuting  N  command  or  beginning a new cycle. Place text on the output
       before reading the next input line.  T} _ 2b  labelT{ Branch to  the  :
       command bearing the label . If label is empty, branch to the end of the
       script. Labels are recognized unique up to eight characters.  T} _  2c\
       textT{  Change.  Delete  the  pattern  space. Place text on the output.
       Start the next cycle.  T} _ 2dT{ Delete the pattern  space.  Start  the
       next  cycle.  T} _ 2DT{ Delete the initial segment of the pattern space
       through the first new-line. Start the next cycle. (See  the  N  command
       below.)   T}  _  2gT{  Replace the contents of the pattern space by the
       contents of the hold space.  T} _ 2GT{ Append the contents of the  hold
       space to the pattern space.  T} _ 2hT{ Replace the contents of the hold
       space by the contents of the pattern space.  T} _ 2HT{ Append the  con‐
       tents of the pattern space to the hold space.  T} _ 1i\  textT{ Insert.
       Place text on the standard output.  T} _ 2lT{  /usr/bin/sed:  List  the
       pattern space on the standard output in an unambiguous form. Non-print‐
       able characters are displayed in octal  notation  and  long  lines  are
       folded.   T}  T{ /usr/xpg4/bin/sed: List the pattern space on the stan‐
       dard output in an unambiguous form. Non-printable characters  are  dis‐
       played in octal notation and long lines are folded. The characters (\\,
       \a, \b, \f, \r, \t, and \v) are written  as  the  corresponding  escape
       sequences.  Non-printable  characters not in that table will be written
       as one three-digit octal number (with a preceding backslash  character)
       for  each  byte  in the character (most significant byte first). If the
       size of a byte on the system is greater than nine bits, the format used
       for  non-printable  characters is implementation dependent.  T} T{ Long
       lines are folded, with the point of  folding  indicated  by  writing  a
       backslash  followed by a NEWLINE; the length at which folding occurs is
       unspecified, but should be appropriate for the output device.  The  end
       of  each  line is marked with a $.  T} _ 2nT{ Copy the pattern space to
       the standard output if default output is not  suppressed.  Replace  the
       pattern  space  with the next line of input.  T} _ 2NT{ Append the next
       line of input to the pattern space with an embedded new-line. (The cur‐
       rent line number changes.) If no next line of input is available, the N
       command verb shall branch to the end of the  script  and  quit  without
       starting  a new cycle and without writing the pattern space.  T} _ 2pT{
       Print. Copy the pattern space to the standard output.  T} _  2PT{  Copy
       the  initial segment of the pattern space through the first new-line to
       the standard output.  T} _ 1qT{ Quit. Branch to the end of the  script.
       Do  not  start  a  new  cycle.   T}  _ 2r  rfileT{ Read the contents of
       rfile. Place them on the output before reading the next input line.  If
       rfile  does not exist or cannot be read, it is treated as if it were an
       empty file, causing no error condition.  T} _ 2t  labelT{ Test.  Branch
       to  the : command bearing the label if any substitutions have been made
       since the most recent reading of an input line or execution of a t.  If
       label  is  empty,  branch  to  the end of the script.  T} _ 2w  wfileT{
       Write. Append the pattern space to wfile. The  first  occurrence  of  w
       will  cause  wfile  to  be  cleared.  Subsequent  invocations of w will
       append. Each time the sed command is used, wfile is overwritten.  T}  _
       2xT{  Exchange  the  contents  of the pattern and hold spaces.  T} _ 2!
       commandT{ Don't. Apply the command (or group, if command is {) only  to
       lines  not  selected by the address(es).  T} _ 0:  labelT{ This command
       does nothing; it bears a label for b and t commands to branch to.  T} _
       1=T{  Place  the  current line number on the standard output as a line.
       T} _ 2{command-list}T{ Execute command-list only when the pattern space
       is selected.  T} _ 0An empty command is ignored.  _ 0#T{ If a # appears
       as the first character on a line of a script  file,  then  that  entire
       line is treated as a comment, with one exception: if a # appears on the
       first line and the character after the # is an n, then the default out‐
       put  will be suppressed. The rest of the line after #n is also ignored.
       A script file must contain at least one non-comment line.  T}



       tab() box; cw(0.92i) |cw(4.58i) cw(0.92i)  |lw(4.58i)  Max  AddrCommand
       (Using   strings)  and  Description  _  2s/regular  expression/replace‐
       ment/flags T{ Substitute the replacement string for  instances  of  the
       regular expression in the pattern space. Any character other than back‐
       slash or newline can be used instead of a slash to delimit the  RE  and
       the  replacement.  Within  the RE and the replacement, the RE delimiter
       itself can be used as a literal character if it is preceded by a  back‐
       slash.   T}  T{  An  ampersand (&) appearing in the replacement will be
       replaced by the string matching the RE. The special  meaning  of  &  in
       this  context can be suppressed by preceding it by backslash. The char‐
       acters \n, where n is a digit, will be replaced by the text matched  by
       the  corresponding  backreference  expression.  For  each backslash (\)
       encountered in scanning replacement from beginning to end, the  follow‐
       ing  character  loses  its  special meaning (if any). It is unspecified
       what special meaning is given to any character other than &, \ or  dig‐
       its.   T}  T{  A  line can be split by substituting a NEWLINE character
       into it. The application must  escape  the  NEWLINE  character  in  the
       replacement  by  preceding it with backslash. A substitution is consid‐
       ered to have been performed even if the replacement string is identical
       to  the string that it replaces.  T} flags is zero or more of: T{ n  n=
       1 - 512. Substitute for just the  nth occurrence of the regular expres‐
       sion.   T}  T{ g Global. Substitute for all nonoverlapping instances of
       the regular expression rather than just the first one. If both g and  n
       are  specified, the results are unspecified.  T} T{ p Print the pattern
       space if a replacement was made.  T} T{ P Copy the initial  segment  of
       the  pattern  space  through the first new-line to the standard output.
       T} T{ w  wfile Write. Append the pattern space to wfile if  a  replace‐
       ment  was  made.  The  first  occurrence  of  w  will cause wfile to be
       cleared. Subsequent invocations of w will append.  Each  time  the  sed
       command is used, wfile is overwritten.  T} _ 2y/ string1 / string2 / T{
       Transform. Replace all occurrences of characters in  string1  with  the
       corresponding  characters in string2. string1 and string2 must have the
       same number of characters, or if  any  of  the  characters  in  string1
       appear  more  than once, the results are undefined. Any character other
       than backslash or NEWLINE can be used instead of slash to  delimit  the
       strings.  Within  string1 and string2, the delimiter itself can be used
       as a literal character if it is preceded by a backslash.  For  example,
       y/abc/ABC/ replaces a with A, b with B, and c with C.  T}


EXAMPLES
       Example 1 An example sed script



       This  sed  script  simulates the BSD  cat  -s command, squeezing excess
       blank lines from standard input.


         sed −n '
         # Write non-empty lines.
         /./     {
                 p
                 d
                 }
         # Write a single empty line, then look for more empty lines.
         /^$/        p
         # Get next line, discard the held <newline> (empty line),
         # and look for more empty lines.
         :Empty
         /^$/        {
                 N
                 s/.//
                 b Empty
                 }
         # Write the non-empty line before going back to search
         # for the first in a set of empty lines.
                 p
         ´


ENVIRONMENT VARIABLES
       See environ(7) for descriptions of the following environment  variables
       that  affect  the execution of sed: LANG, LC_ALL, LC_COLLATE, LC_CTYPE,
       LC_MESSAGES, and NLSPATH.

EXIT STATUS
       The following exit values are returned:

       0      Successful completion.


       > 0    An error occurred.


ATTRIBUTES
       See attributes(7) for descriptions of the following attributes:

   /usr/bin/sed
       tab() box; cw(2.75i) |cw(2.75i) lw(2.75i) |lw(2.75i) ATTRIBUTE  TYPEAT‐
       TRIBUTE VALUE _ Availabilitysystem/core-os _ CSINot enabled


   /usr/xpg4/bin/sed
       tab()  box; cw(2.75i) |cw(2.75i) lw(2.75i) |lw(2.75i) ATTRIBUTE TYPEAT‐
       TRIBUTE VALUE _ Availabilitysystem/xopen/xcu4 _ CSIEnabled _  Interface
       StabilityCommitted _ StandardSee standards(7).


SEE ALSO
       awk(1),  ed(1), grep(1), sed(1g), attributes(7), environ(7), regexp(7),
       standards(7)



Oracle Solaris 11.4               14 Aug 2020                           sed(1)
맨 페이지 내용의 저작권은 맨 페이지 작성자에게 있습니다.
RSS ATOM XHTML 5 CSS3