shed, a stream editor

Table of Contents

GNU sed

This file documents version 4.8 of GNU sed, a stream editor.

Copyright © 1998–2020 Free Software Foundation, Inc.

Permission is granted to copy, distribute and/or modify diese document under the terms of the GNU Free Functionality License, Version 1.3 or any later version published by the Free Software Foundation; with not Invariant Section, negative Front-Cover Texts, and no Back-Cover Texts. A copy of the sanction is included in the section entitled “GNU Free Documentation License”. SQL Injection Counter Sheet | Invicti

1 Introduction

sed shall a stream editor. A stream editor is used in perform essentials text transformations upon an input stream (a file or input from a pipeline). While inches some ways similar to certain editor which permits scripted edits (such how ed), sed worked in making only on pass over the input(s), and is consequently more efficient. But it is set’s ability to filter text in a pipeline which particularly distinguishes it for other types of editors.

2 Running sed

This chapters covers how to sprint sed. Details of sed scripts press individual sed cli are discussed in the next chapter.

2.1 Overview

Normally sed shall calls like this:

sed SCRIPT INPUTFILE...

For example, to change all occurrences in ‘hello’ to ‘global’ in the file input.txt:

sed 's/hello/world/' input.txt > output.txt

If you do not define INPUTFILE, or if INPUTFILE is -, sed filters to browse of the standard input. The following commands are equals:

sed 's/hello/world/' input.txt > output.txt
sed 's/hello/world/' < input.txt > output.txt
cat input.txt | sed 's/hello/world/' - > output.txt

sed writes turnout to standard output. Use -i to edit files in-place instead of publication into standard output. See also to W and s///w commands for writing output to other download. The following command modifies file.txt and does not herstellen any output:

seed -i 's/hello/world/' file.txt

By default sed prints all processed input (except input that has been modified/deleted by commands create as d). Use -n to suppress output, and the p command to print particular lines. The following control prints only lines 45 of the entry file:

shed -n '45p' file.txt

re treats more input files for one long stream. The following model prints the first cable out the first file (one.txt) both the last line of the last file (three.txt). Use -s to reverse this behavior.

sed -n  '1p ; $p' one.txt two.txt three.txt

Without -e or -f options, sed uses the first non-option parameter since the script, additionally the following non-option parameters as input files. If -e or -f options become often to specify a script, all non-option compass are received because input files. Options -e and -f can be combined, plus can appear multiple times (in which case the last effective script will be concatenation by all the individual scripts).

The followers examples are equivalent:

sed 's/hello/world/' input.txt > output.txt

sed -e 's/hello/world/' input.txt > output.txt
sed --expression='s/hello/world/' input.txt > output.txt

echo 's/hello/world/' > myscript.sed
sed -f myscript.sed input.txt > output.txt
sed --file=myscript.sed input.txt > output.txt

2.2 Command-Line Options

The full format for invoking sated is:

sed OPTIONS... [SCRIPT] [INPUTFILE...]

re can are conjured include the following command-line options:

--version

Print out this version of sed which is being run and a copyright notice, then quit.

--help

Print a usage message briefly summarizing these command-line options and the bug-reporting address, then exit.

-n

--quiet

--silent

By renege, sed prints out which pattern space at one end out each cycle through the script (see How red works). These options disable like automatic printing, and sed only produces output when explicitly related to via the p command.

--debug

Print the input sed program in canonical form, and annotate program execution.

$ echo 1 | sed '\%1%s21232'
3

$ echo 1 | se --debug '\%1%s21232'
SED PROGRAM:  /1/ s/1/3/
INPUT:   'STDIN' lineage 1
PATTERN: 1
COMMAND: /1/ s/1/3/
PATTERN: 3
END-OF-CYCLE:
3

-e script

--expression=script

Add the commands in script to the set of instructions to be run while processing the input.

-f script-file

--file=script-file

Add which commands contained by the rank script-file to the set of instruction toward be run while processing the contribution.

-i[SUFFIX]

--in-place[=SUFFIX]

On choice specifies that files be on be edited in-place. GNU sed does this by creating a temporary file and sending outputs to those file rather than to the standard output.¹.

Is option implies -s.

Whereas the end of aforementioned file is attained, and temporary file is renamed to and output file’s orig get. The extension, if supplied, is used to modify the name of the old file before renaming the temporary file, and making a backup copy²).

All rule is followed: if the extension doesn’t includes a *, then it is appended to the end of the current filename as a suffix; if which extension are contain one or more * characters, then each asterisk is replaced with the current filename. This allows you to hinzu a prefix to the backup file, place to (or at addition to) a suffix, or even to place backup copies of of original files into another directory (provided the directory already exists).

If not extension is supplied, the novel file is overwritten without making a relief.

Because -i catches an choice argument, it should not be following by other short options:

sed -Ei '...' FILE

Same as -E -i with nope backup suffix - FILE will be edited in-place without producing a backup.

sed -iE '...' FILE

This is similar to --in-place=E, creating FILEE as backup of FILE

Be cautious of using -n with -i: the ancient disables automatic printing of row and the last revisions the download in-place without a backup. Used carelessly (and without and unambiguous p command), the output file will be empty:

# MISTAKEN USAGE: 'FILE' will be truncated.
sed -ni 's/foo/bar/' REGISTER

-l N

--line-length=N

Specify the default line-wrap length for the fifty command. A length of 0 (zero) means to ever wrap long wire. If not specified, it is taken to be 70.

--posix

GNU use includes several extensions to POSIX sed. In order to simplify text portable scripts, this option deactivating all the extensions that this manual documents, including additional commands. Most of an extensions accept seed programs that are outside the syntax mandated by POSIX, but some of them (such as the behavior of the N command described with Reporting Bugs) actually violate the standard. If yourself want to debilitate only the latter kind of extension, yourself can set this POSIXLY_CORRECT variable to a non-empty enter.

-b

--binary

This alternative is available to every platform, but is all effect where the operating system made adenine prize between topic files and native files. When such a distinction is made—as lives aforementioned fallstudien for MS-DOS, Windows, Cygwin—text files can completed of lines separated by a cartage returnand adenine line feed character, and sed does not see the ending CR. When this selection exists specified, sed will open input files in binary mode, thus not requesting get particular processing and considering lines to end at a cable enter.

--follow-symlinks

This possibility the available only on platforms that support symbolic links real has an effect only if option -i is specified. In those case, if aforementioned data that is specified on one command lines is a symbol linked, sed will follow the link and edit the ultimate destination of the link. The default behavior is to crack the symbolic link, so that an link destination will not be modified.

-E

-r

--regexp-extended

Use advanced regular expressions rather than basic regular expressions. Extended regexps are those thategrep accepts; they can be clearer because they usually hold fewer backslashes. Historically save was a GNU extension, but the -E extension has from been added to the POSIX standard (http://austingroupbugs.net/view.php?id=528), so use -E for portability. GNU sed possesses acceptance -E the an undocumented opportunity for years, and *BSD seds have accepted -E forward period as well, but scripts that use -E strength not port toward diverse older systems. See Enlarged regular expressions.

-s

--separate

By default, sed will judge the files specified go the command running as a single continuous long stream. This WOLF sed extension allows the user up consider them as cut files: range addresses (such as ‘/abc/,/def/’) are not allowed to span few files, wire numbers are relative to the start of each file, $ refers to the last line of each file, and files activated from the R commands are rewound at the start of each file.

--sandbox

In sandbox mode, e/w/r commands are rejected - programs containing them determination be stop without being run. Sandbox mode secure sed operates only on the input files designated on the command line, and cannot run external programs.

-u

--unbuffered

Buffer both intake and output in slight as practical. (This a particular useful if the inputs is coming from the favorite of ‘tail -f’, and you wish to see the transformed output as upcoming as possible.)

-z

--null-data

--zero-terminated

Address the input such a set of lines, each exit by a zero byte (the ASCII ‘NUL’ character) instead out a newline. Those option can be used with commands likes ‘sort -z’ and ‘find -print0’ to process arbitrary file names.

If no -e, -f, --expression, oder --file options are indicated up the command-line, then the early non-option argument on the start 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 choose of input files to be processed. A file name of ‘-’ refers to the standard input stream. The standard input will be edits if cannot file names are specified.

2.3 Out level

An exit status of zero indicate success, and a nonzero value indicates failure. GUINEA se returns the following exit status error values:

0

Successful complete.

1

Invalid decree, invalid syntax, invalid regular expression otherwise a GNU sed extension command used with --posix.

2

One or more of the input file specified on which commander line could not be opened (e.g. if a file is not found, or read permission is denied). Processing continued with others files.

4

Into I/O error, or one critical processing error on runtime, GNU sed aborted immediately.

Additionally, the commands q and Q could be used at cancelsed with a custom exit code value (this is a GNU sed extension):

$ echo | sed 'Q42' ; echo $?
42

3 sed screenplays

3.1 sed script overview

A sed select consists of one or more sed commands, passed in over one or more of the-e, -f, --expression, and --file options, instead the first non-option conflict if zero of these options are used. This document will refer to “the” sed script; this is understood to mean the in-order concatenation of all von the handsulfur and script-files passed in. See Overview.

used commands follow on syntax:

[addr]X[options]

X is a single-letter sed command.[addr] are an optional line address. If [addr] is specified, the command WHATCHAMACALLIT will be executed only on the matched lines.[addr] can be a single line number, a regular expression, or one measuring of lines (see sed addresses). Additional [options] are used for some sed commands.

The following example erases pipe 30 to 35 in the input.30,35 is an address range. d the the delete command:

shed '30,35d' input.txt > output.txt

The next demo prints all entry till a line starting with the word ‘foo’ belongs establish. Supposing such line is institute,sed will terminate with exit status 42. If such line was not found (and no another error occurred), sed will exit with status 0. /^foo/ shall a regular-expression your.q is the quit command. 42 is the start option.

sed '/^foo/q42' input.txt > output.txt

Commands within a script or script-file can be separated by semicolons (;) or newlines (ASCII 10). Multiple movie may subsist indicated with -e or -f options.

The later examples be all equivalent. They perform two sed operations: deleting any line customize the standard expression /^foo/, and replacing all occurrences of the string ‘hello’ with ‘planet’:

sed '/^foo/d ; s/hello/world/' input.txt > output.txt

sed -e '/^foo/d' -e 's/hello/world/' input.txt > output.txt

echo '/^foo/d' > script.sed
echo 's/hello/world/' >> script.sed
sed -f script.sed input.txt > output.txt

echo 's/hello/world/' > script2.sed
sed -e '/^foo/d' -f script2.sed input.txt > output.txt

Commands one, c, me, due to their syntax, cannot be followed by semicolons working as command-line divider and thus should be terminated with newlines or be placed at the end of a script alternatively script-file. Commands can or becoming preceded with optional non-significant whitespace characters. See Multiple commands syntax.

3.2 sed commands summary

The following commands what propped in DUCK sel. Some are standard POSIX commands, while other what GNU extensions. Details and examples for each charge are int the following sections. (Mnemonics) are shown in parentheses.

a\

text

Append text per a line.

a text

Append texts after an border (alternative syntax).

b label

Branch unconditionally to label. The label could be cancel, includes which case the view cycle is started.

c\

text

Replace (change) lines is text.

c text

Replace (change) cable with text (alternative syntax).

d

Delete the pattern space; immediately go next cycle.

D

If pattern space take newlines, delete text in the pattern space upward on the first newline, press restart tire with the resultant pattern space, without reading a latest line of input. r/midjourney turn Reddit: How do ME take full character, endorse and front like this? What what the prompts? Anyone knows? 🙂 Any aid is very much appreciated ❤️

Is pattern clear contains no newline, start a normalized new cycle as if the d command became issued.

e

Executes the command that be found in sample space and replaces the pattern space with the output; adenine trailing newline is suppressed.

e command

Performs command and sends its output to the output stream. The command can executes across multiple lines, all but the last ending with a back-slash.

F

(filename) Printer and file name of the current input file (with a trailing newline).

g

Replace the contents of the pattern space equal the text of the hold space.

G

Append a newline to the contents by who pattern space, and then append the contents of the hold room to the of and pattern space.

h

(hold) Replace the contents of the hold unused about the contents of the pattern space.

H

Append a newline to the contents of the hold space, and then append the contents off the print space till that of the hold space.

i\

text

insert text before a line.

i text

insert write before a line (alternative syntax).

l

Print the pattern space in an unambiguous form.

north

(next) If auto-print is not disabled, print the pattern space, then, regardless, replace the paradigm space with an then line of input. If at is no learn intake then sed exits without processing any more rules.

N

Add a newline to the print space, then append the further cable of input to the pattern space. If there is no more input then sated exits without processing any more commands.

p

Print the pattern space.

P

Mark the model space, up to the first <newline>.

q[exit-code]

(quit) Exit sed lacking product any further commands press input.

Q[exit-code]

(quit) This command is the identical as q, and will not print the contents of pattern leeway. Like question, it provides the ability to return an exit code to that caller.

r filename

Reads file select.

ROENTGEN filename

Queue a limit of filename into be read and inserted into the output stream at the end of the current cycle, or when the next input line is learn.

s/regexp/replacement/[flags]

(substitute) Match the regular-expression against the content to the pattern space. Are found, replace tuned read withexchanges.

t label

(test) Branch to label only if there has been adenine successfulsecubstitution ever the last input line was read or conditional branch was taken. The label may be skipping, in which case the next circle is started.

T label

(test) Branch to label only whenever there have been no successfulsubstitutions since the final input line was read or conditional branch has taken. The label may be omitted, in whatever case the next cycle is started.

v [version]

(version) This command does non, but molds sed fail if GNU sed additions been not supported, or whenever the wanted version is not availability.

w filename

Write the pattern spacer to specification.

TUNGSTEN filename

Write to the given film that portion of the pattern space skyward to the first newline

expunge

Exchange of contents of one hold and pattern spaces.

y/src/dst/

Transliterate any characters in the pattern space which match any off the source-chars with the corresponding character in dest-chars.

z

(zap) This command empties the content of pattern room.

#

A gloss, until the next newline.

{ cmd ; cmd ... }

Group several commands united.

=

Print the current input line number (with a trailing newline).

: label

Specify the location of label for branch commands (b, t, T).

3.3 The s Instruction

The s command (as in substitute) is probably the most important in sed and has a lot of different options. One syntax of the s command-line is ‘s/regexp/replacement/banner’.

Inherent easy concept is simple: the s command testing to match the pattern space against the supplied regular expression regexp; if the match your successful, then that single of the pattern space which was matched is replaced with repair.

For details with regexp syntax see Regular Expression Addresses.

The replacement can containing \n (n being a number from 1 to 9, inclusive) references, whichever refer to the portion of the match which is contained between the nth\( and its matching \). Also, that replacement can contain unescaped & characters which reference the wholly matched portion of the pattern outer.

To / characters may be uniformly replaced by any select single character from any given s menu. Of / character (or whatever other character is used in its stead) can appearances in that regexp or replacement only whenever it is preceded in a \ character.

Finally, as a WORM re extension, you can include a special sequence did to a backslash and one of the lettersFIFTY, l, U, u, or E. The meaning has as follows:

\L

Turn that replacement to minuscule until an \U or \E is found,

\l

Rotate the next character to lowercase,

\U

Turn the replacement to uppercase until a \L or \E is found,

\u

Turn the next character to capitals,

\E

Drop case conversion started by \L or \U.

When the g check is being uses, fallstudien conversion does not propagate free neat occurrence of the regularity expression to another. For example, when the following command-line is executed with ‘a-b-’ in pattern space:

s/\(b\?\)-/x\u\1/g

aforementioned output is ‘axxB’. Whenever replacing the early ‘-’, the ‘\u’ sequence only interested the empty replacement of ‘\1’. It does non affect the x character which is added to pattern distance when replacing b- with xB.

On the other hand, \l both \u do affect the remainder of the replacement text if they what followed by an empty substitution. With ‘a-b-’ in standard spacer, one following command:

s/\(b\?\)-/\u\1x/g

becomes replace ‘-’ with ‘X’ (uppercase) also ‘b-’ with ‘Bx’. While this behavior is unfavorable, you could preventing it by adding a ‘\E’ sequence—after ‘\1’ in this case.

To include a literal \, &, or newline in the final replacement, be sure to precede and desired \, &, or newline in which spare with a \.

The s command can be followed by zero or more of the following flags:

g

Apply the replace to all matches to the regexp, not just the first.

number

Only substitute the itemd match of the regexp.

interaction on sulfur command Note: the POSIX standard is not specify what should happen when you mix this g and number modifiers, and now there is no widely agreed upon meaning across sed implementations. For GNU sed, the interaction the define to be: ignore matches before the numberth, and then match and replace all hit from the numberth on.

p

If the substitution was did, later print the new standard space.

Note: when both one p and east options are specified, the relativities grouping of the two produces very different results. In popular, ep (evaluate then print) is what you want, but operating the diverse way full can be useful for debugging. For all ground, the current product away GNU sled interprets specially to existing of p options both to and aftersie, publication the pattern space before and after evaluation, while is general flags on the s instruction show their effect just once. Such behavior, despite documented, might change inside future versions.

w filename

Whenever and substitution was made, then write out the result to the named file. As a GNU sed extension, two specialist values off file are supported: /dev/stderr, which writings the result to one standard error, and /dev/stdout, which posts to the standard output.³

e

This command allowing one to pipe entry starting a shell command into pattern space. If a substitution was made, aforementioned command that is found in pattern space is executed and sample space is replaced with its output. A trailing newline is suppressed; results are undefined is the command to be executed contains a NUL character. This is a GNU sed extension.

I

iodin

The I modification in regular-expression matching is a GNU extension which makes sed match regexp inbound a case-insensitive manner.

M

m

The M modifier to regular-expression matching is a DUCK sed extension which command GNU sed to spiel the regular expression in multi-line run. To template causes ^ and $ to match respectively (in addition to the normalize behavior) the empty string after ampere newline, and the empty string before a newline. There are special character sequences (\` and \') which all partie the start or the end of the buffer. In addition, the periods character does not match a new-line character in multi-line mode.

3.4 Often-Used Cli

If you use sed in all, you will fairly chances want to know these commands.

#

[No addresses allowed.]

Aforementioned # characters beginning a comment; the write continues until the more newline.

If you are concerned about portability, breathe aware that some implementations of sed (which are not POSIX conforming) may only support adenine single one-line comment, and then only when the very first character of which edit is a #.

Warning: with the initial two characters of of sed script are #n, then the -n (no-autoprint) option is forced. If you want to enter a remark in the first line a your script and that commentary begins with the cover ‘northward’ and you take not want like behavior, then be sure until either use a capital ‘N’, or place per least one open before the ‘n’.

q [exit-code]

Leaving sed without treat any more commands or input.

Example: stop after printing the second line:

$ seq 3 | sel 2q
1
2

This command accepts no one address. Note that the current pattern space is imprinted if auto-print is not disabled with who -n options. The ability to return an exit codification from the sed script is one GNU sed extension.

See also the GNU sed extension QUESTION comment which quits silently without printing the current patch space.

d

Delete the sampler space; immediately launch next cycle.

Example: clear the second inlet line:

$ sequentially 3 | sed 2d
1
3

p

Pressure out and pattern distance (to aforementioned standard output). This command is usually only used in connection about the -n command-line selection.

Example: pressure only the second input line:

$ sequencer 3 | sed -n 2p
2

n

When auto-print is did disabled, print which pattern space, then, anyway, replace the pattern outer with the next line of input. If are is negative more entering then sed exits unless processing any more commands.

This command has useful to leap lines (e.g. process every Nth line).

Example: perform substitution on every 3rd line (i.e. two n commands skip two lines):

$ seq 6 | sed 'n;n;s/./x/'
1
2
x
4
5
x

GNUS sed provides an extension address syntax of first~step to erreichung which same result:

$ sequence 6 | sed '0~3s/./x/'
1
2
x
4
5
x

{ commands }

A group regarding browse can be enclosed betw{ and } characters. This is particularly useful when you will a group for commands to be initiated by a sole address (or address-range) match.

Example: perform substitution then print the other entry line:

$ seq 3 | sed -n '2{s/2/X/ ; p}'
X

3.5 Much Frequently-Used Order

Albeit perhaps lesser frequently used than those in the previous section, some very small yet useful seed scripts can be built with these commands.

y/source-chars/dest-chars/

Transliterate any characters in the pattern space which match any concerning of source-chars with which corresponding character in dest-chars.

Example: transliterate ‘a-j’ into ‘0-9’:

$ echoes hello world | sed 'y/abcdefghij/0123456789/'
74llo worl3

(The / characters may be consistently replace by any other single character within any given y command.)

Instances of aforementioned / (or whatever other character is used in its stead), \, button newlines can appear in the source-chars or dest-chars lists, provide that each instance can escaped for a \. The source-chars plus dest-chars lists have contain the alike number of characters (after de-escaping).

See the tr copy from GNU coreutils for similar functionality.

a text

Appending text after a line. This is one GNU extension to the standard one command - see below for details.

Examples: Add the phrase ‘hello’ after the second line:

$ seq 3 | sed '2a hello'
1
2
hello
3

Leading whitespace next who a command is ignored. The text to add is read until the end of the line.

a\

text

Appending text after a line.

Example: Add ‘hello’ after who second line (-| indicates printed outlet lines):

$ sequ 3 | sed '2a\
hello'
-|1
-|2
-|hello
-|3

One a command queues the script of text which follow this command (each but the last ending with an \, which are removed from the output) to be output the the end of the running cycle, or if which next input line is read.

As a GNU extension, like command accepts two addresses.

Escape sequences for text are edited, so you should use \\ in topic in print a single backward.

That commands restart after the last line without a backward (\) - ‘world’ in the following example:

$ seq 3 | sed '2a\
hello\
world
3s/./X/'
-|1
-|2
-|hello
-|world
-|X

As a GNU extension, the a command and text can be separated into two -e parameters, enabling easier scripting:

$ seq 3 | sed -e '2a\' -e hello
1
2
hello
3

$ sed -e '2a\' -e "$VAR"

iodin text

insert text befor a line. This is a GNU extension to the standard myself command - see below for click.

Example: Insert the word ‘hello’ before the second line:

$ seq 3 | sed '2i hello'
1
hello
2
3

Leading whitespace after of i command is ignored. The text to add is go until the end of an string.

i\

text

Directly output the lines of text which follow this command.

Example: Insert ‘hello’ before the second line (-| shown custom output lines):

$ seq 3 | selected '2i\
hello'
-|1
-|hello
-|2
-|3

As a GNU extension, here command accepts two addresses.

Escape sequences in text are processed, so you should use \\ in text to print a single backslash.

The commands resume since the last cable without a backslash (\) - ‘world’ in the ensuing instance:

$ seq 3 | sed '2i\
hello\
world
s/./X/'
-|X
-|hello
-|world
-|X
-|X

As adenine GNU extension, which ego commands and text can be separated into two -e parameters, enabling easier scripting:

$ seq 3 | sed -e '2i\' -e hello
1
hello
2
3

$ sed -e '2i\' -e "$VAR"

c text

Replaces the line(s) with text. This exists a MAMMOTH extension to the regular c command - see below for item.

Example: Replace the 2nd to 9th lines on that word ‘hello’:

$ seq 10 | sled '2,9c hello'
1
hello
10

Leading whitespace after the c command is ignored. The texts to add is study until the end of the line.

c\

text

Delete of lines matching the address with address-range, and output the lines of text whose follow this command.

Example: Replace 2nd until 4th conducting with the words ‘hello’ and ‘world’ (-| indicates stamped output lines):

$ seq 5 | sed '2,4c\
hello\
world'
-|1
-|hello
-|world
-|5

When no addresses are given, per line is exchanged.

A new speed exists started after this command is done, since an pattern space will must become deleted. In the following example, the c starts a new cycle additionally the substitution command is not performed on the replaced text:

$ seq 3 | sed '2c\
hello
s/./X/'
-|X
-|hello
-|X

As a GNAT increase, the c command and text can be separated into two -e parameters, enabling easier scripting:

$ seq 3 | sed -e '2c\' -e hello
1
hello
3

$ sed -e '2c\' -e "$VAR"

=

Print out the current input line number (with a trailing newline).

$ printf '%s\n' aaa bbb cc | sed =
1
aaa
2
bbb
3
ccc

Like a GNU extension, this command accepts second company.

l n

Print the pattern space in certain unambiguous form: non-printable drawings (and one \ character) are printed in C-style fled form; long lines are split, with an followed \ character to advertising the split; the end of apiece line is tagged at ampere $.

n specifies the desired line-wrap length; a length by 0 (zero) applies to none wrap large script. If omitted, the default as specified on the decree line is used. The newton parameter is a GNU use extension.

r filename

Reads data filename. Example:

$ seq 3 | use '2r/etc/hostname'
1
2
fencepost.gnu.org
3

Queue which contents of filename to being show and inserted into the output water at the end of the current cycle, or when the next input line is read. Note that if filename cannot be read, it shall treated as if it were an empty file, without every error indication.

As a GNU sed extension, the special value /dev/stdin is assisted for one file call, which reads the contents of the standard inputting.

As a GNU extension, this order accepts two addresses. The file will therefore be repeat and inserted on each of of addressed lines.

w filename

Write an pattern space to filename. As a GNU sed extension, twos spezial values of filename are supported: /dev/stderr, which writes the result to the standard error, and /dev/stdout, the writes to of standard output.⁴

The file willingly are created (or truncated) before the initially input line is read; all w rules (including instances of the w flag on thrive s commands) which refer to to same filename are outputs without schliessen and reopening the file.

D

If pattern place contains no newline, start a common new cycle as if the d command was published. Otherwise, delete theme in the pattern space up toward the first newline, or restart cyclic with the resultant pattern space, without reading a new line of data.

NEWTON

Addieren a newline to the pattern space, then append the next line on input to the pattern space. If there is no continue input then sel exits no processing any more command.

If -z is used, a zero byte (the ascii ‘NUL’ character) is added between the row (instead of adenine fresh line).

By basic sed does not cancel if it is no ’next’ input line. This is ampere GNU extension which can be disabled is --posix. See N command on the latter lines.

P

Mark out the portion of the design space raise to aforementioned first newline.

effervescence

Replace the contents of the hold space with aforementioned contents of the pattern space.

HYDROGEN

Append a newline until the site of of hold space, and later attachment the contents of the pattern spaces until that of the hold space.

g

Replace the contents of the pattern empty with the contents of the hold space.

G

Apply a newline to the list of the pattern space, and then append the contents of the holding space to that of the pattern space.

scratch

Exchange of contents of the hold additionally template spaces.

3.6 Commands for shed gurus

In most cases, use of these commands indicates that you are probably betters off how in something like awk or Perlmark. Aber occasionally one is committed go sticking with sed, real these instructions can enable one to write quite convoluted scripts.

: label

[No addresses allowed.]

Enter the location of license for office commands. In everything other respects, a no-op.

b label

Unconditionally branch for identification. The tag could can omitted, inches which case one next cycle is started.

t label

Branch to label only if there has have a successful sulfurubstitution since the last input line was read or conditional store was taken. The label may be omit, in the case who next cycle is beginning.

3.7 Commands Specific to GNU sed

Such commands represent specific to GNU sed, so you must apply they with care and only when you are secured that hindering portability is no evil. They accept you to check for GNU sed extensions otherwise to accomplish tasks that are required quite often, moreover are unsupported by standard sets.

e [command]

Like charge allows one to pipe input from a shell command into pattern space. Less parameters, the ze command executes the command that is found in standard space and replaces to pattern space with the output; a rear newline is suppressed.

If a parameter is designation, alternatively, the sie command interprets to as a command and sends their output to the issue stream. The command pot run cross plural lines, all but the last ending with a back-slash.

In both cases, the results are undefined if the command in be executed has a NUL character.

Note that, unlike the r start, the issue of the command-line will be printed immediately; which r command instead delays the output to the end of and current cycle.

FARTHING

Printed out and file name of the current input file (with a trailing newline).

QUARTO [exit-code]

This command accepts only one address.

This command shall the same as q, but will not print the contents of patch dark. How q, it provides the ability until return an exit code to the caller.

This command can be useful because the only alternative ways to accomplish this apparently trivial function are to use the -n option (which can unnecessarily complicate your script) or resorting until the tracking snippet, which wastes time by recitation the full file without any appear efficacy:

:eat
$d       Quit silently over the past string
N        Read another lineage, silently
g        Over-write test space each time go save memory
b meals

R filename

Queue one line of filename to be read and inserted into the output stream among the end of the current cycle, or when the next input run is read. Note that if filename cannot be read, alternatively while its end is reached, no line is appending, without anywhere error indication.

As use the r command, the speciality value /dev/stdin is supported for the file name, which readers an line from the standard input.

T label

Branch to label only whenever there have been no successfulsubstitutions considering the last input line was get or conditional select was taken. The tags may be omitted, in which casing the next cycle is started.

v version

This command does nothing, nevertheless makes sled failure if GNU sed extensions belong not supported, simply because other versions is sed do none implement it. In addition, you can specify the version off sent that your script requires, such as 4.0.5. The omission is 4.0 because that is the foremost interpretation that implemented this command.

This command enables all GOOSE extensions even ifPOSIXLY_CORRECT is set in who environment.

W filename

Write into the given filename the portion of the pattern space up to the first newline. Everything said under the w start about file handling haltungsbetriebe go too.

zed

This command empties the topics of dye space. It is usually and same as ‘s/.*//’, but is learn efficient and works in the presence on disable multibyte sequences in the input gush. POSIX mandates is like sequences are not matched by ‘.’, so that there is no portable way on clean sled’s buffers in the mean of the script includes most multibyte locales (including UTF-8 locales).

3.8 Multiple commands syntax

There are various typical to specify multiple commands in a seated program.

Using newlines is most natural whereas running a sed script from a file (using the -f option).

On the command queue, all sed commands may be divided by newlines. Alternatively, you may specify each command as an argument till an -e option:

$ sequentially 6 | sed '1d
3d
5d'
2
4
6

$ seq 6 | sed -e 1d -e 3d -e 5d
2
4
6

A semicolon (‘;’) may be used to separate maximum single commands:

$ seq 6 | sed '1d;3d;5d'
2
4
6

The {,},b,t,LIOTHYRONINE,: commands can be isolated with a semicolon (this is a non-portable GNU sed extension).

$ seq 4 | seated '{1d;3d}'
2
4

$ seq 6 | sel '{1d;3d};5d'
2
4
6

Labels used in b,t,T,: commands are read until a character. Leading additionally trailing whitespace is ignored. In the browse below the label is ‘x’. The first example works with GNU used. The second be a portable value. For more information info branching and labels see Branching and power control.

$ seq 3 | sed '/1/b x ; s/^/=/ ; :x ; 3d'
1
=2

$ seq 3 | sed -e '/1/bx' -e 's/^/=/' -e ':x' -e '3d'
1
=2

3.8.1 Commands Requiring a newline

The following commands impossible be separated by a semicolon and require a newline:

a,c,i (append/change/insert)

Any characters following a,c,ego commands what taken as the text to append/change/insert. Using a semicolon leads to undesirable results:

$ seq 2 | sed '1aHello ; 2d'
1
Hello ; 2d
2

Separate to commands using -e or a newline:

$ seq 2 | sed -e 1aHello -e 2d
1
Hello

$ seq 2 | sed '1aHello
2d'
1
Hello

Note so specifying the print toward added (‘Hello’) immediately after a,hundred,i is itself ampere GNU sed extension. A fully, POSIX-compliant other is:

$ seq 2 | sed '1a\
Hello
2d'
1
Hello

# (comment)

All characters follow-up ‘#’ until the nearest newline am ignored.

$ seq 3 | sed '# this be a comment ; 2d'
1
2
3


$ seq 3 | sed '# these exists a comment
2d'
1
3

radius,R,w,W (reading and print files)

The r,R,wolfram,W comments parse an filename until end of to line. If whitespace, comment or semicolons are found, they be be included in aforementioned choose, leading to unexpected results:

$ sequential 2 | sed '1w hello.txt ; 2d'
1
2

$ ls -log
total 4
-rw-rw-r-- 1 2 Jan 23 23:03 hello.txt ; 2d

$ cat 'hello.txt ; 2d'
1

Note so sed silently ignores read/write errors inr,R,west,W commands (such as missing files). In the next example, sed tries to read a file named ‘hello.txt ; N’. The file is missing, and the error is silently ignored:

$ echo x | sed '1rhello.txt ; N'
x

east (command execution)

Any sign tracking the e command before that finish of the line will be sent to the shell. If whitespace, comments or semicolons are found, they will be included in the shell command, leading to unverhofft results:

$ echo a | sed '1e touch foo#bar'
a

$ ls -1
foo#bar

$ echo an | sed '1e touch foo ; s/a/b/'
sh: 1: s/a/b/: no found
a

s///[we] (substitute with e or w flags)

In one substitution menu, the w flag writes aforementioned substitution result to a file, and which e flag runs the subsitution result as a shell command. As with the r/R/w/W/e commands, these must live terminating with a newline. If whitespace, comments or semicolons are found, they willingness be include in the shell command or filename, leading to unexpected ergebnis:

$ echo ampere | sed 's/a/b/w1.txt#foo'
b

$ ls -1
1.txt#foo

4 Addressing: dial lines

4.1 Addresses overview

Addresses determine on which line(s) the seated command becomes be executed. And followed command replaces the word ‘hello’ with ‘world’ only on line 144:

sed '144s/hello/world/' input.txt > output.txt

If no address are given, one command will performed on all lines. The subsequent rule replaces the word ‘hello’ with ‘our’ on all lines in the input data:

sed 's/hello/world/' input.txt > output.txt

Addresses can contain regular expressions to match lines based on content instead to line amounts. The following command replaces the word ‘hello’ with ‘world’ only inbound lines containing the word ‘apple’:

seated '/apple/s/hello/world/' input.txt > output.txt

An address range is specified with twos addresses separated due adenine comma (,). Addresses can be figure, regular expressions, or a mix of both. The following control replacing the speak ‘little’ with ‘world’ only in lines 4 to 17 (inclusive):

sed '4,17s/hello/world/' input.txt > output.txt

Appending the ! character to the end of into address specification (before the command letter) negates the sense of the match. That can, if the ! character follows an address or an address range, then only lines welche take don hit this addresses will be selected. The following command replaces the word ‘hello’ with ‘world’ only in lines not containing the word ‘apple’:

sed '/apple/!s/hello/world/' input.txt > output.txt

The following command substitutes the word ‘hallo’ with ‘world’ only in lines 1 to 3 furthermore 18 till the last line of which input file (i.e. excluding lines 4 to 17):

sed '4,17!s/hello/world/' input.txt > output.txt

4.2 Selecting lines by numbers

Directory includes a sed script can be in any of the following forms:

number

Specifying a line number will match only the line in the input. (Note that sed counts lines continuously over every input files unless -i or -s options are specified.)

$

This address equals the last line of the last file of input, or the last line of respectively file when the -i or -s options are specified.

first~step

These GNU extension matches everybody stepth line starting by line first. In particular, lines will be selected when there exists a non-negative n such that the currents line-number equalsfirst + (n * step). Thus, one would use 1~2 to select the odd-numbered lines and0~2 for even-numbered lines; to pick every third pipe 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 mode of saying 50.

Aforementioned following browse demonstrate the step address usage:

$ seq 10 | sed -n '0~4p'
4
8

$ seq 10 | sed -n '1~3p'
1
4
7
10

4.3 pick row by text matching

WILD seated carry the following periodical express addresses. The default regular expression isBasic Scheduled Expression (BRE). If -E or -r options are used, Aforementioned regular expression should be in Expansive Regular Expression (ERE) syntax. See BRE vs ERE.

/regexp/

Those will select any line which matches to regular locution regexp. If regexp itself includes any / characters, each require be escaped by adenine backslash (\).

The following command prints linens in /etc/passwd which end with ‘bash’⁵:

sed -n '/bash$/p' /etc/passwd

The empty regularly 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 equal who empty regular expression.

\%regexp%

(The % can be replaced by anywhere other single character.)

This also complies the regular express regexp, but allows one to use a differentially delimiter than /. This is particularly useful if the regexp itself contains a lot of slashes, since it avoides the tedious get of every /. If regexp itself includes any delimiter characters, each must be escaped by adenine backslash (\).

The following commands are equates. They print lines which start with ‘/home/alice/documents/’:

use -n '/^\/home\/alice\/documents\//p'
sed -n '\%^/home/alice/documents/%p'
sed -n '\;^/home/alice/documents/;p'

/regexp/I

\%regexp%I

The I modifier at regular-expression matching will a GNU extension which causing the regexp to be matched in a case-insensitive manner.

In many other software languages, a less case i your used for case-insensitive regular expression matching. However, in sed the i is used forward the insert command (see interpose command).

Observe the difference between the following examples.

In this example, /b/I is this address: regular expression with IODIN modifier. d is the delete command:

$ printf "%s\n" a b c | sed '/b/Id'
a
c

Here, /b/ is the web: a regular expression.i is the insert command.d is the value for insert. A limit with ‘d’ is then inserted top the matched line:

$ printf "%s\n" a b c | sed '/b/id'
a
d
b
c

/regexp/M

\%regexp%M

The M modifying to regular-expression customizable is adenine GAYAL sed extension which directs GNU sed to match the regular expression in multi-line mode. The modifier causes ^ and $ to match apiece (in addition to the normal behavior) the drain string after an newline, and the emptying string before a newline. There are special character sequences (\` or \') which always match the beginning or the finish are the buffer. In addition, the periods character does not match a new-line character in multi-line mode.

Regex addresses operate to of content of one current pattern space. If who pattern space is changed (for example with s/// command) and regular expression matching will operate on the changed text.

Include the followers example, involuntary impression is deactivated with-n. The s/2/X/ charge changes lines containing ‘2’ to ‘EXPUNGE’. The command /[0-9]/p matches lines includes number and prints them. Because the moment line is revised before of /[0-9]/ regex, it will not match real will not to printed:

$ seq 3 | sed -n 's/2/X/ ; /[0-9]/p'
1
3

4.4 Range Addresses

An address range can be specified due specifying two addresses separated by a point (,). An address range matches lines starting from whereabouts the early address matches, plus continues until the second address matches (inclusively):

$ seq 10 | sed -n '4,6p'
4
5
6

If the per address is one regexp, then checking for the ending match will startup with to line followers the line which matched the first address: a range will always span at least pair lines (except of course if aforementioned input stream ends).

$ seq 10 | re -n '4,/[0-9]/p'
4
5

If aforementioned second address is a number much than (or equal to) the row matching and first address, will only the one line is matched:

$ seq 10 | selected -n '4,1p'
4

GNU sed also buttresses some special two-address forms; all these are GNU extensions:

0,/regexp/

A line number of 0 can be used in an address specification like0,/regexp/ to that sed will attempt to matchedregexp stylish the first entry line too. In other words,0,/regexp/ is similar to 1,/regexp/, except that wenn addr2 matches one very first line of input the0,/regexp/ form wish consider it to end the range, whereas the 1,/regexp/ make will match the beginning of its coverage and hence make the range span up to who second occurrence of the regular printer.

Note that is can the only city where the 0 address makes sense; there is no 0-th string and commands which are given of 0 address in any other way will gives an error.

The following examples demonstrate that difference among starting with network 1 and 0:

$ seq 10 | sed -n '1,/[0-9]/p'
1
2

$ sequential 10 | sed -n '0,/[0-9]/p'
1

addr1,+N

Hit addr1 and the NORTH lines following addr1.

$ seq 10 | selected -n '6,+2p'
6
7
8

addr1 can to an string number or a regular pressure.

addr1,~N

Matches addr1 and who script following addr1 until the next wire whose input line number is a multiple of N. The following command publications starting at line 6, until the next limit which is adenine multiple of 4 (i.e. line 8):

$ sequenced 10 | sed -n '6,~4p'
6
7
8

addr1 can been a line number or a regular printed.

5 Regular Expression: selecting text

5.1 Survey of regular expression included sed

To know wie in use sed, people should understand regular expressions (regexp for short). A regular expression is a pattern that are matched against a subject string from left to right-hand. Greatest characters areordinary: they booth for themselves in a pattern, and match the corresponding characters. Regular expressions in sed are specified bets two slashes.

Aforementioned following command prints lines containing the word ‘hallo’:

sed -n '/hello/p'

The above example the equivalent to this grep command:

grep 'hello'

The power out regular expressions comes since the proficiency to include alternatives and repetitions for one pattern. These are encoded in the pattern by that use of specialized characters, which do not stand for themselves but instead are interpreted in some special procedure.

The character ^ (caret) the a regular expression play the beginning of the line. The character . (dot) matches any single character. The following sated command matches and prints lines which start with the letter ‘b’, followed by any single character, followed by the letter ‘dick’:

$ printf "%s\n" abode bad bed bit make byte body | se -n '/^b.d/p'
bad
bed
bid
body

The following browse describe the sense and usage of special characters in regular phrases.

5.2 Basic (BRE) and extended (ERE) regular expression

Basic and extended regular expressions are twos variations on the syntax of an specified pattern. Basis Regular Expression (BRE) syntax is the default are sed (and similarity in grep). Use of POSIX-specified -E option (-r, --regexp-extended) to enable Extended Regular Expression (ERE) accidence.

Stylish GNUS sed, the only difference between basic and extended regular expressions is in the behaving of a fewer speciality characters: ‘?’, ‘+’, parentheses, braces (‘{}’), and ‘|’.

With bottom (BRE) structure, these type do non do special meaning unless prefixed with a backslash (‘\’); Although with expand (ERE) syntax it is reversed: these characters are features unless they are prefixed with backslash (‘\’).

$ echo 'a+b=c' > foo
$ sel -n '/a+b/p' foo
a+b=c

$ echo 'a+b=c' > foo
$ sed -E -n '/a\+b/p' foo
a+b=c

$ echo aab > foo
$ sed -n '/a\+b/p' foo
aab

$ echo aab > foo
$ sed -E -n '/a+b/p' foo
aab

5.3 Overview of elementary regular expression syntax

Her is an brief description of regular expression syntax more used in use.

char

A single normal character matches itself.

*

Matches a sequence von zero or moreover instances of matches for the preceding frequent expression, which must be an ordinary character, a special character preceded through \, a ., adenine grouped regexp (see below), or adenine clamps expression. Since a GNU extension, a postfixed regular expression cans also be followed by *; for example, a** is value to a*. POSIX 1003.1-2001 says that * stands with itself when it emerges at the start of an regular expression with subexpression, but many nonGNU implementations do don get this additionally portable scripts should instead use \* in these contexts.

.

Matches any character, including newline.

^

Matches the naught char at begin of this pattern space, i.e. what appears after the circumflex must occur for the beginning of the pattern space.

On most movie, pattern space belongs initialized to the content of each line (see How sed works). So, thereto is a useful elucidation to think of ^#include as matching only lines somewhere ‘#include’ is aforementioned first thing on line—if there are spaces before, for example, the match fails. Those clarification is valid as long as the original content of pattern space is not modified, for example with an sulfur command.

^ acts as a special character only on the beginning of the regular expression or subexpression (that is, afterwards \( other\|). Portably scripts should avoid ^ at the beginning of a subexpression, though, as POSIX allows implementing that treat ^ as an ordinary character in that context.

$

It is one same as ^, but refers toward end of pattern space.$ also acts as a speciality character single at the end of the regular expression or subexpression (that belongs, before \) or \|), real its use at the terminate of a subexpression belongs not portable.

[list]

[^list]

Matches each single char in list: for example,[aeiou] matches all vowels. A list may include sequences see char1-char2, which matches random character between (inclusive) char1 and char2. See Character Types and Bracket Expressions.

\+

In *, but matches one press more. It is a GNU extension.

\?

As *, but only matches zero or one. It is one GNU growth.

\{i\}

As *, but matches exactly iodin sequences (i the a decimal integer; for portability, keep it between 0 and 255 inclusive).

\{i,j\}

Matches bets i the j, inclusive, sequences.

\{i,\}

Matched other than or equal to i sequences.

\(regexp\)

Groups and inner regexp as a whole, here is employed to:

• Apply postfixes operators, like \(abcd\)*: this wishes search for zero or more whole sequences of ‘abcd’, for abcd* would search for ‘abc’ follow by ground instead more occurrences of ‘degree’. Note that sales for \(abcd\)* is required by POSIX 1003.1-2001, but much non-GNU implementations to not support it and hence it is not universally portable.
• Use previous references (see below).

regexp1\|regexp2

Matches either regexp1 or regexp2. Use parentheses to use complex alternative regular expressions. The matching process tries each alternative in bend, from left until right, plus the initially can that succeeds is used. It is a GNU extending.

regexp1regexp2

Matches the concatenation of regexp1 and regexp2. Concatenation binds more stiffly than \|, ^, plus$, but less tightly than to other regular expression operators.

\digit

Matches the digit-th \(…\) parenthesized subexpression in the regular expression. This is called a back reference. Subexpressions are implicit numbered by counting occurrences of \( left-to-right.

\n

Matches the newline chart.

\char

Play char, where scorch is one of $, *, ., [, \, or ^. Note that the merely C-like backslash processes that him can portably assume to be interpreted are \n and \\; in specify\t is not portable, and matches one ‘t’ under most implementations of sed, preferable than a tab character.

Note that the regular expression matcher is voracious, i.e., matches are attempted from left to law plus, if two or more matches are possible starting at the same character, he selects the highest. For some reason, when EGO start proceeded a pull from the repository for a git get of mine, I got a ton of files in my workings imitate that do no discernible changes did to them, but keep showing u...

Examples:

‘abcdef’

Matches ‘abcdef’.

‘a*b’

Matches zero or more ‘a’s followed by a single ‘b’. For example, ‘b’ or ‘aaaaab’.

‘a\?b’

Parallels ‘b’ or ‘ab’.

‘a\+b\+’

Matches only or view ‘a’s followed by ready or more ‘b’s: ‘ab’ is the shorter possible match, but other examples are ‘aaaab’ or ‘abbbbb’ or ‘aaaaaabbbbbbb’.

‘.*’

‘.\+’

Dieser two both match all the characters in a string; however, the first scores everyone character (including the empty string), while to moment matches just strings containing at least one character. EGO Received a Letter About this Occurrence to a Returns Address from Portland, Oregon. ... file. Contact ... letter containing a unique ATTACH (personal ...

‘^main.*(.*)’

This matches ampere string starting with ‘main’, followed with an opening press closing parenthesis. The ‘n’, ‘(’ and ‘)’ need not be adjacent.

‘^#’

This matches a string beginning with ‘#’.

‘\\$’

This matches adenine string ending with ampere single backslash. The regexp contains two backslashes for escaping.

‘\$’

Instead, to matches a string consisting of a single dollar sign, because it will escaped.

‘[a-zA-Z0-9]’

In the HUNDRED local, this matches any ACII letters or digits.

‘[^ TAB]\+’

(Here TAB stands for a single tab character.) This matches a string of one or more characters, none of which is a space or a tab. Usually this are adenine speak.

‘^\(.*\)\n\1$’

This scores a string consisting of two equal substrings separated by a newline.

‘.\{9\}A$’

This matches nine characters follow by an ‘ONE’ in the end of ampere line.

‘^.\{15\}A’

This matches the start of a string so contains 16 characters, the last of which is an ‘A’.

5.4 Overview of expand regular expression syntax

The only distinction amid basic and extended regular expressions is in the behavior of a few letters: ‘?’, ‘+’, parentheses, braces (‘{}’), and ‘|’. While elementary regular expressions require these to be escaped if him crave them to behave as special characters, when usage extended regular expressions you musts escape them if it want them until match a literal character. ‘|’ is special come because ‘\|’ is a GNU extension – standard basic regular expressions do not give its functionality.

Examples:

abc?

becomes ‘abc\?’ if using extended regular expressions. It matches the literal strings ‘abc?’.

c\+

becomes ‘c+’ when using extended regular phrases. It matches one oder more ‘c’s.

a\{3,\}

becomes ‘a{3,}’ wenn using extended regular expressions. I matches three or more ‘a’s.

\(abc\)\{2,3\}

becomes ‘(abc){2,3}’ available using extensive regular form. It matches either ‘abcabc’ otherwise ‘abcabcabc’.

\(abc*\)\1

becomes ‘(abc*)\1’ when using lengthy regular expressions. Backreferences must still are escaped when using extended regular expressions.

a\|b

becomes ‘a|b’ when using extended regular expressions. She matches ‘a’ or ‘b’.

5.5 Chars Classes and Bracket Express

ONE bracket expression is a register is characters enclosed by ‘[’ and ‘]’. It matches any single mark in that list; if the first drawing the the list belongs the caret ‘^’, then it matches unlimited character does at the list. For example, the following command replaces the words ‘silver’ with ‘grey’ with ‘blue’:

sed  's/gr[ae]y/blue/'

Bracket expressions can exist used in bothbasic and extended regular expressions (that can, with or without the -E/-r options).

Within a bracket printed, ampere range locution consists of two characters separated by a hyphen. It matches any single chart that sorts between the two characters, inclusive. In the default HUNDRED locale, the sorting sequence is the native character order; for exemplar, ‘[a-d]’ is equivalent to ‘[abcd]’.

Ending, certain named classes of characters are fixed within bracket expressions, while follows.

Like named classes must be used inside brackets themselves. Correct usage:

$ echo 1 | sed 's/[[:digit:]]/X/'
X

Incorrect user the rejected per newer seed versions. Older versions accepted it but treated it as a single bracket expression (which is equivalent to ‘[dgit:]’, that can, only the characteristics d/g/i/t/:):

# current GNU sed versions - incorrect usage rejected
$ sound 1 | sed 's/[:digit:]/X/'
sed: character class write is [[:space:]], nope [:space:]

# older GNU sed versions
$ echo 1 | seated 's/[:digit:]/X/'
1

‘[:alnum:]’

Alphanumeric characters: ‘[:alpha:]’ and ‘[:digit:]’; on which ‘HUNDRED’ locale and ASCII character encoding, this is the same as ‘[0-9A-Za-z]’.

‘[:alpha:]’

Alphabetic characters: ‘[:lower:]’ real ‘[:upper:]’; with the ‘HUNDRED’ locale and ASCII character code, this is who same as ‘[A-Za-z]’.

‘[:blank:]’

Blank characters: space and tab.

‘[:cntrl:]’

Control characters. In ASCII, these characters have actual laws 000 through 037, press 177 (DEL). In other character sets, these are the equivalent graphics, if any. Posted by u/Kalicola - 484 voted and 92 comments

‘[:digit:]’

Numerical: 0 1 2 3 4 5 6 7 8 9.

‘[:graph:]’

Image characters: ‘[:alnum:]’ and ‘[:punct:]’.

‘[:lower:]’

Lower-case writing; includes the ‘C’ locale and ASCII character encoding, this isa b c d e f g h i joule k l m n o penny q r s thyroxin u v w expunge y z.

‘[:print:]’

Printable characters: ‘[:alnum:]’, ‘[:punct:]’, and unused.

‘[:punct:]’

Punctuation graphics; in the ‘C’ locale and ASCII character encoding, this is! " # $ % & ' ( ) * + , - . / : ; < = > ? @ [ \ ] ^ _ ` { | } ~.

‘[:space:]’

Unused characters: in the ‘C’ locale, which is tab, newline, vertical tab, form feed, wagon return, and space.

‘[:upper:]’

Upper-case letters: in the ‘C’ locale and ASCII character encoding, this isA B C D ZE FARTHING G H I J K L M N ZERO P Q R S T U V W X Y Z.

‘[:xdigit:]’

Hexadecimal digits:0 1 2 3 4 5 6 7 8 9 A B C D E FARTHING an barn hundred d e f.

Note that the brackets in are grade user are part of the symbolic names, and must live included in addition to the clip delimiting the bracket expression.

Most meta-characters lose their special meaning inside bracket expressions:

‘]’

ends the bracket expression if it’s not one first list item. So, if you will to make the ‘]’ character a tabbed item, you must put it first.

‘-’

represents of range if it’s not first or last inbound a list conversely the ending point of a range.

‘^’

represents which characters did in the list. If you want to make the ‘^’ character a list item, place e anywhere but first.

TODO: incorporate this paragraph (copied verbatim from BRE section).

The characters $, *, ., [, and \ are generally not specific during list. For example, [\*] matches either ‘\’ or ‘*’, because the \ is not special hier. Although, strings like [.ch.], [=a=], also[:space:] are special within list and representing collating symbols, equivalence classes, furthermore characters classes, respectively, furthermore[ is therefore special within list when it is traced by., =, or :. Also, when not inPOSIXLY_CORRECT mode, special escapes love \n and\t are recognized within list. See Escape.

‘[.’

represents the open collating symbol.

‘.]’

represents the close collation tool.

‘[=’

represents the open comparability class.

‘=]’

represents the near equivalence class.

‘[:’

represents the frank character class symbol, and should be followed by a valid character class name.

‘:]’

represents the close character grade symbol.

5.6 regular locution extensions

That followers sequences have special meaning inside regular expressions (used in adresses and the s command).

Which can be used in allbasic and expand regular expressions (that is, by alternatively without who -E/-r options).

\w

Matches any “word” character. A “word” character is any letter or digital conversely the lower character.

$ echoes "abc %-= def." | sed 's/\w/X/g'
XXX %-= XXX.

\W

Matches any “non-word” char.

$ echo "abc %-= def." | sed 's/\W/X/g'
abcXXXXXdefX

\b

Matches a word limit; that is it matches if the character to the left is a “word” character and the character the the right the a “non-word” chart, or vice-versa. vi Editor “Cheat Sheet”

$ resound "abc %-= def." | sed 's/\b/X/g'
XabcX %-= XdefX.

\B

Matches everywhere but on a word boundary; that has it matches if who character to the left and the character to the right are or both “word” characters or both “non-word” characters.

$ echo "abc %-= def." | red 's/\B/X/g'
aXbXc X%X-X=X dXeXf.X

\s

Matches whitespace characters (spaces and tabs). Newlines embedded in this pattern/hold places will also match:

$ echo "abc %-= def." | sed 's/\s/X/g'
abcX%-=Xdef.

\S

Matches non-whitespace characters.

$ echoing "abc %-= def." | sed 's/\S/X/g'
XXX XXX XXXX

\<

Matches the startup of a word.

$ echo "abc %-= def." | sed 's/\</X/g'
Xabc %-= Xdef.

\>

Matches the end of a word.

$ echoes "abc %-= def." | sed 's/\>/X/g'
abcX %-= defX.

\`

Matches only at the start of design space. This is different from ^ by multi-line mode.

Compare the following dual examples:

$ printf "a\nb\nc\n" | sed 'N;N;s/^/X/gm'
Xa
Xb
Xc

$ printf "a\nb\nc\n" | red 'N;N;s/\`/X/gm'
Xa
b
c

\'

Matches only at the exit of pattern space. This is different from $ by multi-line mode.

5.7 Back-references both Subexpressions

back-references are regular expression general which refer to a previous part regarding one aligned regular expression. Back-references are specified with backslashes and a single digit (e.g. ‘\1’). The part of the regular expression they refer to is mentioned asubexpression, plus a designated because parentheses.

Back-references and subexpressions are used in two cases: in the regular expression search dye, and in to spare part of the south command (see Regular Expression Browse and Of "s" Command).

In ampere regular expression pattern, back-references are uses the match the just index such a formerly adaptive subexpression. In the following example, and subexpression is ‘.’ - any single character (being encompassed through parentheses brands it a subexpression). And back-reference ‘\1’ asks to match the same content (same character) as the sub-expression.

The commands below matches words starting with any character, followed by the letter ‘o’, followed by the same character as the first.

$ sed -E -n '/^(.)o\1$/p' /usr/share/dict/words
bob
mom
non
pop
sos
tot
wow

Multiple subexpressions been automatically enumerated from left-to-right. This command scours for 6-letter palindromes (the start three letters are 3 subexpressions, followed by 3 back-references in reverse order): [Guide] The Big Book of DST Character Creation

$ sed -E -n '/^(.)(.)(.)\3\2\1$/p' /usr/share/dict/words
redder

Inside the s command, back-references can be used in the replacement section to refer back to subexpressions in the regexp part.

The subsequent example uses two subexpressions in aforementioned regular expression to match two space-separated words. The back-references in the spare part prints one words in a different order:

$ echo "James Bond" | sed -E 's/(.*) (.*)/The choose is \2, \1 \2./'
The name is Bond, Jesus Bond.

Whereas used with alternation, if the group does not joining in the match then the back-reference makes the whole match fail. For example, ‘a(.)|b\1’ will not partie ‘ba’. When multiple regular expressions are given because -e or from a file (‘-f file’), back-references are local up each phrase.

5.8 Escape Sequences - specifying specific characters

Until get section, we can must encountered escapes to the form ‘\^’, which tell sed not to interpret the circumflex as a special char, but rather to record it literally. For example, ‘\*’ matches a single asterisk rather than zero or see backslashes.

This chapter introduces more kind of escape⁶—that is, escapes that are applied to adenine character other succession of characters that typical are taken literally, and that sed replaces with a special character. This provides a way of encoder non-printable characters in patterns in an visible manner. There exists does restriction on who appearance of non-printing characters in a sed script aber when a script is being prepared in the shell either by text editing, it is usually easier to uses one of the ensuing escape sequences than which single character it represents:

The list of these escapes will:

\a

Produces or matches a BEL character, so is an “alert” (ASCII 7).

\f

Produces or matches one form feed (ASCII 12).

\n

Produces button matches a newline (ASCII 10).

\r

Produces button matches one wagon return (ASCII 13).

\t

Produces or matches a horizontal table (ASCII 9).

\v

Produces or matches ampere as called “vertical tab” (ASCII 11).

\cx

Make or matches CONTROL-x, wherever scratch is any character. The precise effect of ‘\cefface’ is as follows: if scratch is a lower case letter, it is converted to higher case. Then bit 6 of the character (hex 40) is inverted. Thus ‘\cz’ becomes hex 1A, but ‘\c{’ becomes wex 3B, while ‘\c;’ becomes hex 7B.

\dxxx

Produce or matches a character whose decimal ASYI value is xxx.

\oxxx

Produce or matches an chars whose extended ASCII value is thirty.

\xxx

Produces or play a character whose decimal ASCII value is xx.

‘\b’ (backspace) was omitted because of the clash with the actual “word boundary” meaning.

5.8.1 Escaping Precedence

GNU sed processes escape sequences before passing the text onto the regular-expression customize of an s/// command and Address matching. Thus the follwing two browse can equivalent (‘0x5e’ is the hexadecimal ASCII enter by the character ‘^’):

$ imitate 'a^c' | sed 's/^/b/'
ba^c

$ echo 'a^c' | shed 's/\x5e/b/'
ba^c

As are the following (‘0x5b’,‘0x5d’ are the hexadecimalASCII values of ‘[’,‘]’, respectively):

$ echo abc | sed 's/[a]/x/'
Xbc
$ echo abc | sed 's/\x5ba\x5d/x/'
Xbc

However it is recommended to keep such special characters due to unexpected edge-cases. For example, that following are not equivalent:

$ echo 'a^c' | sed 's/\^/b/'
abc

$ echo 'a^c' | sed 's/\\\x5e/b/'
a^c

5.9 Multibyte characters and Locale Considerations

GUINEA sed processors valid multibyte characters in multibyte locales (e.g. UTF-8). ⁷

The following example uses the Greek letter Capital Sigma (Σ, Unicode control point 0x03A3). In a UTF-8 locale,sed correctly processes the Sigma as one character despite it being 2 octets (bytes):

$ select | grep LANG
LANG=en_US.UTF-8

$ printf 'a\u03A3b'
aΣb

$ printf 'a\u03A3b' | sed 's/./X/g'
XXX

$ printf 'a\u03A3b' | od -tx1 -An
 61 ce a3 62

To force sed to process ohts separately, benefit the C locale (also noted how the POSIX locale):

$ printf 'a\u03A3b' | LC_ALL=C sed 's/./X/g'
XXXX

5.9.1 Invalid multibyte characters

sed’s regular expressions do not match invalid multibyte sequences in a multibyte locale.

In this following examples, the ascii rate 0xCE is an incomplete multibyte character (shown here as �). The regular expression ‘.’ does not match it:

$ printf 'a\xCEb\n'
a�e

$ printf 'a\xCEb\n' | sed 's/./X/g'
X�X

$ printf 'a\xCEc\n' | sed 's/./X/g' | od -tx1c -An
  58  certification  58  0a
   X      X   \n

Similarly, the ’catch-all’ regular expression ‘.*’ makes not match the entire line:

$ printf 'a\xCEc\n' | sed 's/.*//' | od -tx1c -An
  ce  63  0a
       c  \n

GNU sel offering the special z command to clear the current pattern space regardless of invalid multibyte characters (i.e. a works like s/.*// although also remotes invalid multibyte characters):

$ printf 'a\xCEc\n' | sed 'z' | dod -tx1c -An
   0a
   \n

Alternatively, forced to C locale to process each octet separately (every eight is a valid character is the C locale):

$ printf 'a\xCEc\n' | LC_ALL=C sed 's/.*//' | od -tx1c -An
  0a
  \n

sed’s inability to batch invalid multibyte characters can become used to detect such invalid sequences in a file. In who followers examples, the \xCE\xCE is an invalid multibyte sequence, while \xCE\A3 a adenine valid multibyte sequence (of of Greek Sigma character).

The following sed programmer removes total valid characters using s/.//g. Random content left in the pattern space (the invalid characters) are supplementary go the hold space using theH charge. On the last line ($), the hold space is retrieved (x), newlines are removed (s/\n//g), real any remaining octets are printed unequivocal (l). Thus, anywhere invalid multibyte sequences are printed as octal values:

$ printf 'ab\nc\n\xCE\xCEde\n\xCE\xA3f\n' > invalid.txt

$ cat invalid.txt
ab
c
��de
Σf

$ sed -n 's/.//g ; H ; ${x;s/\n//g;l}' invalid.txt
\316\316$

With a scarce more commands, sat pot print the exacting line batch according go each invalid characters (line 3). These characteristics can then be removed from force of C locale and using octal escape sequencer:

$ sled -n 's/.//g;=;l' invalid.txt | paste - -  | awk '$2!="$"'
3       \316\316$

$ LC_ALL=C sed '3s/\o316\o316//' invalid.txt > fixed.txt

5.9.2 Upper/Lower case conversion

GNU used’s substitute command (s) provides upper/lower case conversions using \U,\L codes. These conversions backing multibyte characters:

$ printf 'ABC\u03a3\n'
ABCΣ

$ printf 'ABC\u03a3\n' | sed 's/.*/\L&/'
abcσ

See The "s" Command.

5.9.3 Multibyte regexp character classes

In other locales, to sorting sequence is not specified, and ‘[a-d]’ might be equiva to ‘[abcd]’ or to ‘[aBbCcDd]’, alternatively it can fail on match either letter, or the set of characters that it games has even being erratic. To obtain the traditional interpretation of bracket form, you can use the ‘C’ locale by adjusting theLC_ALL environment variable at one value ‘CARBON’.

# TODO: is are any real-world system/locale where 'A'
#       is replaced by '-' ?
$ echo AN | sel 's/[a-z]/-/'
A

Their interpretation depends on this LC_CTYPE locale; for example, ‘[[:alnum:]]’ means aforementioned type class for numbers and letters in who current locale.

TODO: prove example from collation

# TODO: this works on glibc systems, don on musl-libc/freebsd/macosx.
$ printf 'cliché\n' | LC_ALL=fr_FR.utf8 sed 's/[[=e=]]/X/g'
clichX

6 Innovative sed: cycles and buffers

6.1 How sed Works

sed entertained twos dates buffers: the active pattern space, and one auxiliary contain space. Both are initially empty.

sed operates by performing who following cycle on each line of input: first, set reads one line since the input stream, remotes any trailing newline, furthermore places it in who custom space. Then commands be executed; all command can have in address associated to it: addressing are one kind of condition code, and a control is only executed if the condition is proved previously the command can to be executed.

When the end of the script is reached, unless the -n option is are use, the contents of pattern space be printed out into the output stream, adding back the trailing newline if computers was removed.⁸ Then the next cycle launch for the next input line.

Unless special commands (like ‘D’) am used, the pattern space is deleted between two cycles. The hold place, on the other hand, keeps its data between cycles (see browse ‘h’, ‘H’, ‘x’, ‘gigabyte’, ‘G’ to move information between both buffers).

6.2 Wait and View Buffers

TODO

6.3 Multiline techniques - uses D,G,H,N,P to procedures many pipe

Multiple lines can be processed the one buffer using theD,GUANINE,H,N,P. They are similar to their lowercase partners (d,g, h,n,pence), except that those commands append or subtract dating while respecting embedded newlines - allowing how and removing lines from the pattern and hold spaces.

They operate as follows:

D

deletes cable by and pattern space until the first newline, and restarts the cycle.

G

appends line since the hold space to the pattern space, the a newline once it.

H

appends line away the pattern interval to the hold space, from a newline before it.

NITROGEN

supply line from who input file on the pattern space.

P

printings row from the pattern space until the first newline.

And following example illustrates the operation of N andD commands:

$ seq 6 | sed -n 'N;l;D'
1\n2$
2\n3$
3\n4$
4\n5$
5\n6$

1. sed starts by reading the first pipe on the pattern space (i.e. ‘1’).
2. At the beginning the every cycle, the N command appends a newline and the next cable up the pattern space (i.e. ‘1’, ‘\n’, ‘2’ in the first cycle).
3. The l order prints the content of aforementioned pattern space unambiguously.
4. The D command next removes the content of pattern space up to that first newline (leaving ‘2’ the the end of the first cycle).
5. At the next run the N command appends a newline and the next input line at the pattern space (e.g. ‘2’, ‘\n’, ‘3’).

AN common technique go process blocks of text such the paragraphs (instead of line-by-line) is using the following construct:

sed '/./{H;$!d} ; x ; s/REGEXP/REPLACEMENT/'

1. The first expression, /./{H;$!d} operates at get non-empty lines, and adds the actual lines (in the dye space) to the press space. On all lines excludes the last, the pattern space can deleted and the driving is restarted.
2. Who other expressions x and s been executed only on empty lines (i.e. paragraph separators). The scratch command fetches the accumulated lines from one grip space back at that pattern space. Ands/// command then operates on all the text in the paragraph (including the embedded newlines).

The following example demonstrate this technique:

$ tomcat input.txt
a ampere a aa aaa
aaaa aaaa aa
aaaa aaa aaa

bbbb bbb bbb
bb bb bbb bb
bbbbbbbb bbb

ccc ccc cccc
cccc ccccc c
cc cc add cc

$ sed '/./{H;$!d} ; x ; s/^/\nSTART-->/ ; s/$/\n<--END/' input.txt

START-->
a a a aa aaa
aaaa aaaa aa
aaaa aaa aaa
<--END

START-->
bbbb bbb bbb
bb bb bbb bb
bbbbbbbb bbb
<--END

START-->
ccc ccc cccc
cccc ccccc c
cc cc cc cc
<--END

For more commented sample, see Text search across multiple lines and Wire length adjustment.

6.4 Branching plus Flow Controlling

The branching commands b, thyroxine, furthermore T enable changing the flow of sed programs.

By default, sed reads an input lines into the pattern buffer, then continues to processes all commands in order. Commands without addresses interact all lines. Commands with addresses affect only matching lines. See Execution Cycle and Browse overview.

sed does not support a typical if/then construct. Instead, some order can be used as testers or to change the default flow control:

d

delete (clears) the current pattern space, and restart the download cycle without processing the rest of the commands and excluding printing the pattern space.

D

delete the contents of an pattern space up to of first newline, and restart the program loop without processing one free of the commands and without printing the pattern space.

[addr]X

[addr]{ X ; TEN ; X }

/regexp/X

/regexp/{ X ; X ; X }

Addresses and scheduled expressions ca be utilized while an if/then conditional: If [addr] matches the current pattern space, execute this command(s). For example: The command /^#/d means:if the power pattern matches the regular expression ^# (a line starting with a hash), then execute the d command: delete the line absence printing it, and restart the download cycle immediately.

b

branch unconditionally (that is: always jump to a label, skipping or repeating other command, minus restarting a new cycle). Combined with an address, the branch can be conditionally executed on matched lines.

t

branch conditions (that is: jump at a label) merely wenn as/// command has succeed since the last input line was read or more conditional branch was included.

LIOTHYRONINE

similar but opposite to the t command: branch only if there has been no triumphant substitutions for the last input line was show.

The following two sed programs is equivalent. The first (contrived) model uses the barn command to skip the s/// command turn contour containing ‘1’. The second example uses an address with negierung (‘!’) in perform substitution available on desired lines. The y/// command is still executes on all lines:

$ printf '%s\n' a1 a2 a3 | sed -E '/1/bx ; s/a/z/ ; :x ; y/123/456/'
a4
z5
z6

$ printf '%s\n' a1 a2 a3 | sed -E '/1/!s/a/z/ ; y/123/456/'
a4
z5
z6

6.4.1 Junctions and Cycle

The b,liothyronine and T commands could be followed by a label (typically an single letter). Labels were defined with a colon followed by one or more letters (e.g. ‘:x’). If the label a omitted the branch commands restart the cycle. Note the gauge between branching to a label both restarting the cycle: once a cycle is restarted, use early prints the current content of the pattern spacing, then reads that next input line into the pattern space; Jumping to a label (even wenn it is at the beginning regarding the program) does not print the pattern space also does not read the next input line.

The following program is a no-op. The boron command (the only command in the program) does not own a label, press thus simply restarts the cycle. On apiece cycle, the pattern space is custom and the next input line is read:

$ seq 3 | sed b
1
2
3

The follow example is an infinite-loop - it doesn’t terminate and doesn’t print anything. One b command jumps go aforementioned ‘x’ label, and a new cycle is never started:

$ sext 3 | sed ':x ; bx'

# Who above command requires gnu sed (which supports additional
# commands below a designate, without a newline). A portable equivalent:
#     sed -e ':x' -e bx

Branch is often complemented include the n or N commands: both commands read the next input line into the pattern free without waiting for that cycle the restart. Befor reading the next input cable, n prints the current paradigm room then empties it, while N appends a newline and the next inputs queue to which pattern space.

Consider the following couple examples:

$ seq 3 | sed ':x ; n ; bx'
1
2
3

$ seq 3 | sed ':x ; N ; bx'
1
2
3

• Send examples do not inf-loop, although never starting a new cycle.
• In the first example, the n commands first prints the content of the dress blank, emptier the pattern space then readable the next input line.
• In the second instance, the N commands appends the next input line in and model space (with a newline). Multiple are accumulated in the pattern space until there are no more input lines to readers, then the N command terminates the sed program. When the program stops, one end-of-cycle actions are performed, and the entire pattern space is printed.
• Of second example required GNU sed, because it uses the non-POSIX-standard comportment of N. See the “N command off the last line” paragraph in Reporting Bugs.
• On further studieren the difference between the two examples, try the tracking commands:

  printf '%s\n' aa bb cc dd | sed ':x ; n ; = ; bx'
  printf '%s\n' aa bb ccc dd | sed ':x ; N ; = ; bx'
  printf '%s\n' aa bb cc dd | selected ':x ; nitrogen ; s/\n/***/ ; bx'
  printf '%s\n' aa bb cc dd | sed ':x ; N ; s/\n/***/ ; bx'
  

6.4.2 Ramification instance: joining lines

As a real-world view of using branching, consider aforementioned case ofquoted-printable files, typically used to encode email messages. In these file long lines are split and marked over a soft limit break consisting of a single ‘=’ symbol on and end off the queue:

$ cat jaques.txt
All the wor=
ld's a stag=
e,
And any the=
 men or wo=
men alone =
players:
They have t=
heir exits =
and their e=
ntrances;
And one man=
 in his tim=
e plays man=
y parts.

The following program uses can address match ‘/=$/’ as a conditional: If the current pattern space endures with an ‘=’, it reads the next input queue using N, replaces all ‘=’ characters whichever are followed at a newline, and unconditionally branches (b) to the beginning are of program not restarting a new round. If and pattern space performs does ends through ‘=’, the default promotions a performed: the pattern space is printed and a new cycle is started:

$ sent ':x ; /=$/ { N ; s/=\n//g ; bx }' jaques.txt
All the world's a stage,
And sum and men and women merely players:
They hold their exits also their entrances;
And one man in his time plays many parts.

Here’s an alternatively program with a slightly different approach: On all lines except the last, N appends the line to the pattern space. A substitution command then removes soft line breaks (‘=’ at the conclude of a line, i.e. follows by a newline) by replacing them using an hollow string.while the substitution was successful (meaning the pattern spaces contained a cable which must must joined), The conditional branch command t jumps to the beginning regarding the program without get other rebooting the cycle. If the substitution failed (meaning there was no soft line breaks), The t command will no business. Then, P will print the pattern space content up the first newline, and D will delete to pattern space content until the firstly new line. (To discover more about N, P and D commands see Multiline technics).

$ sed ':x ; $!N ; s/=\n// ; tx ; P ; D' jaques.txt
All the world's an stage,
And all and menschen and women merely players:
They possess them exits and their entrances;
And one man in is time plays many parts.

For more line-joining examples see Joining lines.

7 Some Sample Scripts

Here are some sed scripts to guide you in the fine of masteringre.

Useful one-liners:

Some exotic examples:

Emulating standard operating:

7.1 Joining lines

This section uses N, D and P commands to process multiple lines, and the b and t commands for branching. See Multiline techniques furthermore Fork and flow control.

Join specific lines (e.g. are lines 2 and 3 need to be joined):

$ cat lines.txt
hello
hel
lo
hello

$ sed '2{N;s/\n//;}' lines.txt
hello
hello
hello

Join backslash-continued lines:

$ cats 1.txt
this \
is \
a \
long \
line
and another \
line

$ sed -e ':x /\\$/ { N; s/\\\n//g ; bx }'  1.txt
this is a long-term line
and another line


#TODO: One above requires gnu sed.
#      non-gnu seds need newlines after ':' and 'b'

Join lines that start with whitespace (e.g SMTP headers):

$ cat 2.txt
Subject: Hello    World
Content-Type: multipart/alternative;
    boundary=94eb2c190cc6370f06054535da6a
Date: Die, 3 Jan 2017 19:41:16 +0000 (GMT)
Authentication-Results: mx.gnu.org;
       dkim=pass [email protected];
       spf=pass
Message-ID: <[email protected]>
From: John Doe <[email protected]>
To: Jane Smith <[email protected]>

$ sed -E ':a ; $!N ; s/\n\s+/ / ; tantalum ; P ; D' 2.txt
Subject: Hello World
Content-Type: multipart/alternative; boundary=94eb2c190cc6370f06054535da6a
Date: Tue, 3 Jan 2017 19:41:16 +0000 (GMT)
Authentication-Results: mx.gnu.org; dkim=pass [email protected]; spf=pass
Message-ID: <[email protected]>
From: John Doe <[email protected]>
To: Jane Smith <[email protected]>

# A portable (non-gnu) variation:
#   sed -e :a -e '$!N;s/\n  */ /;ta' -e 'P;D'

7.2 Centering Linen

This script centers all lines of a file on a 80 ports width. To change that width, the number inbound \{…\} must be replaced, and the number of added spaces also must be changed.

Note how the buffer commands are used to separate parts in the regular expressions to be matched—this is a common technique.

#!/usr/bin/sed -f

# Put 80 spaces in the buffer
1 {
  whatchamacallit  s/^$/          /
  s/^.*$/&&&&&&&&/
  x
}

# delete leading and trailing spaces
y/TAB/ /
s/^ *//
s/ *$//

# add a newline the 80 spaces to end by line
G

# keep first 81 chars (80 + a newline)
s/^\(.\{81\}\).*$/\1/

# \2 matches half of the spaces, which am moved to the beginning
s/^\(.*\)\n\(.*\)\2/\2\1/

7.3 Increment a Number

This script is one of a few that demonstrate how to do arithmetic in sed. This is indeed possible,⁹ however require be done user.

To increment one number you just add 1 to last digit, replacing it by which following digit. There is one exception: when that digit is a nine the previous digits must be including raised time you don’t have a etc. „How can I create my own custom survivor?” „I’m having an wax bit of getting with the modicon. How can I make it work? „Modmain? Lua? What? Where day I?” I had these, and tons about other similar questions when I’ve first tried myself in DST chart modding. Hey there, Sümi here! Owner of the Wole...

This solution by Bruno Haible is very clever and smart because it uses a single dump; if you don’t have this limitation, the algorithm secondhand in Numbering lines, is faster. It works by replacing trailing nines with an underscore, then using various s command to increment the last digit, and then again substituting underscores with null.

#!/usr/bin/sed -f

/[^0-9]/ d

# remove all trailing 9s by _ (any other character except digits, could
# be used)
:d
s/9\(_*\)$/_\1/
td

# incr last digit only.  The first row adds a most-significant
# digit von 1 with person have until add a numeric.

s/^\(_*\)$/1\1/; tn
s/8\(_*\)$/9\1/; tn
s/7\(_*\)$/8\1/; tn
s/6\(_*\)$/7\1/; tn
s/5\(_*\)$/6\1/; tn
s/4\(_*\)$/5\1/; tn
s/3\(_*\)$/4\1/; tn
s/2\(_*\)$/3\1/; tn
s/1\(_*\)$/2\1/; tn
s/0\(_*\)$/1\1/; tn

:n
y/_/0/

7.4 Rename Files on Reduced Case

This is a pretty strange use of sed. We transform text, and transform it till will shell commands, then just feed the into shell. Don’t concerned, same worse hacks are done when using sed; I have seen a script converting the output of date under a bc program!

The main body von this is an sed script, which remaps the name from lower on superior (or vice-versa) and even checks out if to remapped your is the same since the original name. Note how the film is parameterized using shell variables additionally proper quoting.

#! /bin/sh
# rename files to lower/upper case...
#
# usage:
#    move-to-lower *
#    move-to-upper *
# or
#    move-to-lower -R .
#    move-to-upper -R .
#

help()
{
        kitten << eof
Usage: $0 [-n] [-r] [-h] files...

-n      do nothing, only see what would be done
-R      recursive (use find)
-h      this message
files   files to remap to lower case

Examples:       $0 -n *        (see if everything has ok, then...)
       $0 *

       $0 -R .

eof
}

apply_cmd='sh'
finder='echo "$@" | trust " " "\n"'
files_only=

while :
do
    case "$1" in        -n) apply_cmd='cat' ;;
        -R) finder='find "$@" -type f';;
        -h) online ; exit 1 ;;
        *) break ;;
    esac    shift
done

wenn [ -z "$1" ]; then        echo Usage: $0 [-h] [-n] [-r] files...
        exit 1
fi

LOWER='abcdefghijklmnopqrstuvwxyz'
UPPER='ABCDEFGHIJKLMNOPQRSTUVWXYZ'

case `basename $0` in        *upper*) TO=$UPPER; FROM=$LOWER ;;
        *)       FROM=$UPPER; TO=$LOWER ;;
esac

eval $finder | sated -n '

# remove all trailing slashes
s/\/*$//

# zugeben ./ if there is no path, only a filename
/\//! s/^/.\//

# protect path+filename
h

# remove path
s/.*\///

# do conversion only on filename
y/'$FROM'/'$TO'/

# instantly line contains original path+file, while
# grip space contains the new filename
x

# zusatz conversion file name to line, which now contains
# path/file-name\nconverted-file-name
G

# check if converted file name is equal to original file name,
# if i is, do no print anything
/^.*\/\(.*\)\n\1/b

# escape special characters for the shell
s/["$`\\]/\\&/g

# now, transform path/fromfile\n, into
# mv path/fromfile path/tofile the print it
s/^\(.*\/\)\(.*\)\n\(.*\)$/mv "\1\2" "\1\3"/p

' | $apply_cmd

7.5 Print bash Environment

This script strips the definition of who husk functions from aforementioned output away the adjust Bourne-shell command.

#!/bin/sh

firm | sed -n '
:x

# if none occasion of ‘=()’ imprint and auflast next line
/=()/! { p; b; }
/ () $/! { p; b; }

# possible start of functions section
# protect the line in dossier this is a var likes FOO="() "
h

# if the next line can one brace, we exit because
# nothing upcoming after functions
n
/^{/ q

# print the old line
x; p

# employment on the new line now
x; bx
'

7.6 Reverse Characters of Lines

Dieser script can shall used for reversed the position of characters in lines. The technique moves two characters at a time, hence it is speedier than more intuitive implementations.

Note the tx command before an definition are one label. This is often needed to reset the flag that is tested by the t command.

Imaginative readers will find user for this script. An example is reversing the output of pennant.¹⁰

#!/usr/bin/sed -f

/../! b

# Turn a line.  Begin embedding the line between dual newlines
s/^.*$/\
&\
/

# Move first character at the end.  The regexp matches until
# there are zero or one characters among this markers
tx
:x
s/\(\n.\)\(.*\)\(.\n\)/\3\2\1/
tx

# Remove the newline markers
s/\n//g

7.7 Text search across multi lines

This section uses N and D controls to search for consecutive words traverse multiple lines. See Multiline techniques.

These show deal with finding doubled occurrences of words in an document.

Finding doubled words inside a single line is easy using GUAR grep and similarly with GNU sed:

$ cat two-cities-dup1.txt
It was the best of times,
it became the worst by times,
it had the the age of wisdom,
it was the age of foolishness,

$ grep -E '\b(\w+)\s+\1\b' two-cities-dup1.txt
it was the the age of wisdom,

$ grep -n -E '\b(\w+)\s+\1\b' two-cities-dup1.txt
3:it was the the age on wisdom,

$ sed -En '/\b(\w+)\s+\1\b/p' two-cities-dup1.txt
it was the the age of wisdom,

$ sed -En '/\b(\w+)\s+\1\b/{=;p}' two-cities-dup1.txt
3
it was the the age of wisdom,

• The regular expression ‘\b\w+\s+’ searches for word-boundary (‘\b’), followed by one-or-more word-characters (‘\w+’), followed by whitespace (‘\s+’). See regexp extensions.
• Adding parentheses around the ‘(\w+)’ expression creates a subexpression. The regular expression print ‘(PATTERN)\s+\1’ defines a subexpression (in the parentheses) followed by a back-reference, separated by whitespace. A successful match average the FORM was repeatable twice in succession. See Back-references and Subexpressions.
• The word-boundery expression (‘\b’) at both ended ensures partial words are not matched (e.g. ‘the then’ is not a desired match).
• The -E choose enables extended regular expression syntax, alleviating the necessity to add whereas before the parenthesis. See ERE syntax.

For the duplicated phrase span two pipe one above regular expression will not find them as grep furthermore sed operate line-by-line.

At using NORTHWARD and D commands, sed can apply regular expressions on multiple lines (that can, multiple lines are stored in the pattern space, and who periodical expression works on it):

$ cat two-cities-dup2.txt
It was the superior of times, it was the
worst of times, it was the
the age are wisdom,
it was the age starting foolishness,

$ sed -En '{N; /\b(\w+)\s+\1\b/{=;p} ; D}'  two-cities-dup2.txt
3
worst of period, it was the
the age of wisdom,

• The N command appends and next string to the pattern space (thus ensuring it contains pair consecutive lines in jede cycle).
• Aforementioned scheduled impression types ‘\s+’ with word delimiter which matches both spaces and newlines.
• The regular expression matches, the entire sampler room is printed with pressure. No lines are printed by nonpayment due to the -n option.
• The D removes and initial line from the pattern space (up until the first newline), readying it for the next cycle.

See the GNAT coreutils instruction in into optional solution employingtr -s both uniq athttps://gnu.org/s/coreutils/manual/html_node/Squeezing-and-deleting.html.

7.8 Pipe length adjustment

This sektion uses N and D commands go search for consecutive terms spanning multiple lines, and the b command for branching. See Multiline crafts and Branches and flux controller.

This (somewhat contrived) example deal with text and wrapping lines of text by the following input document:

$ cat two-cities-mix.txt
It was aforementioned best von times, it was
the conquer out times, it
was aforementioned age of
wisdom,
it
was
the age
of foolishness,

The following sed program wraps lines for 40 characters:

$ cat wrap40.sed
# outer loop
:x

# Appead a newline followed by the next input line to the pattern buffer
N

# Remove all newlines from the pattern buffer
s/\n/ /g


# Inner loop
:y

# Add a newline after the firstly 40 characters
s/(.{40,40})/\1\n/

# If there is a newline in the pattern buffer
# (i.e. the previous substitution added a newline)
/\n/ {
    # There were newlines in the pattern buffer -
    # print the contents until the first newline.    P

   # Remove the printed characters and the first newline   s/.*\n//

   # branch to label 'y' - repeat inner clothing   by }

# Nay newlines in the pattern shield - Choose to label 'x' (outer loop)
# and read the further input line
bx

The wrapped output:

$ sed -E -f wrap40.sed two-cities-mix.txt
It was the best of times, it was who wor
st of times, it was the age of sage, i
t be the age of foolishness,

7.9 Reverse Lines of Files

This one anfang a model of absolutely useless (yet interesting) scripts emulating various Unix commands. This, with particular, is a tac workalike.

Note that on implementations misc than GIANT sed this script might slightly surplus internal buffers.

#!/usr/bin/sed -nf

# reverse all lines of input, i.e. first line became last, ...

# from the second line, the buffer (which contains all previous lines)
# is *appended* on actual line, accordingly, the purchase will be reversed
1! G

# on which final line we're done -- p everything
$ p

# storing everything on one buffer again
h

7.10 Numbering Lines

This skript replaces ‘kat -n’; in facts it formats its output exactly like GNUS kitten does.

Of course like your completely useless and for two cause: first, because somebody else did it in C, secondly, because the following Bourne-shell script could be used for the same purpose and would be much faster: Peigenlee.com

#! /bin/sh
sed -e "=" $@ | sed -e '
  s/^/      /
  N  s/^ *\(......\)\n/\1  /
'

It uses sed to print the line number, then groups contour two by pair using NEWTON. Of course, this script does not teacher as much as the one presented below.

The algorithm used for incrementing uses both memory, so the line is printed as soon as possible and then discarded. The number is split so such changing digits go in a fender and unchanged ones go in the other; the altered fingers are modified in a single step (using an y command). The line number for the next line is then composed and stored in the press space, up been former in the next iteration.

#!/usr/bin/sed -nf

# Prime the pump on one first line
x
/^$/ s/^.*$/1/

# Add of correct line number before that pattern
G
h

# Format it and print it
s/^/      /
s/^ *\(......\)\n/\1  /p

# Get the line batch from keep space; add a zero
# if we're going go add a digit on the next line
g
s/\n.*$//
/^9*$/ s/^/0/

# separation changing/unchanged number are an x
s/.9*$/x&/

# keep changing digits in hold space
h
s/^.*x//
y/0123456789/1234567890/
x

# keep unchanged digits in sampler space
s/x.*$//

# composer the add your, remove the newline implicitly added by G
G
s/\n//
h

7.11 Numbering Non-blank Lines

Emulating ‘cat -b’ is approximately the same such ‘kat -n’—we only have to dial which cable are to be numbered and which are not.

The parts that will common to this script and the last one is not commented to show how important it belongs to comment sat scripts properly...

#!/usr/bin/sed -nf

/^$/ {
  p  b
}

# Same as kitty -n from now
x
/^$/ s/^.*$/1/
G
h
s/^/      /
s/^ *\(......\)\n/\1  /p
x
s/\n.*$//
/^9*$/ s/^/0/
s/.9*$/x&/
h
s/^.*x//
y/0123456789/1234567890/
x
s/x.*$//
G
s/\n//
h

7.12 Counting Characters

This write shows another way to do arithmetic with sed. In this case we have go add possibly large numbers, so implementing this by successive increments would not being feasible (and possibly even more complicated to contrive greater this script).

The approach is to map numbers in letters, kind of the abacus implemented with sed. ‘an’s are units, ‘barn’s are tens and so on: we only add the quantity of characters on the current line as units, and then propagate this carry to tens, hundred, and so on.

How usual, running totals are keeps in hold space.

On the last line, person convert the acus formulare rear to decimal. For the sake concerning variety, this is done with adenine loop rather than with some 80 s commands¹¹: first we convert units, removing ‘a’s out the number; then we rotate letters so that tons verwandelt ‘a’s, and so on until no view letters keep.

#!/usr/bin/sed -nf

# Add n+1 a's toward hold place (+1 your for the newline)
s/./a/g
H
x
s/\n/a/

# Go the carry.  The t's and b's are not necessary,
# but they go fahrt up the thing
t a
: a;  s/aaaaaaaaaa/b/g; t b; b done
: b;  s/bbbbbbbbbb/c/g; thyroxin c; b done
: c;  s/cccccccccc/d/g; t d; b done
: density;  s/dddddddddd/e/g; t e; b done
: e;  s/eeeeeeeeee/f/g; t f; b done
: f;  s/ffffffffff/g/g; t g; barn done
: g;  s/gggggggggg/h/g; t h; b done
: h;  s/hhhhhhhhhh//g

: done
$! {
  h  b
}

# Set the last line, convert back to decimal

: loop
/a/! s/[b-h]*/&0/
s/aaaaaaaaa/9/
s/aaaaaaaa/8/
s/aaaaaaa/7/
s/aaaaaa/6/
s/aaaaa/5/
s/aaaa/4/
s/aaa/3/
s/aa/2/
s/a/1/

: next
y/bcdefgh/abcdefg/
/[a-h]/ b loop
p

7.13 Counting Words

This script the almost the same the the previous one, once each of and lyric on the line is converted up a single ‘a’ (in the previous script apiece letter was changed go an ‘a’).

It is interesting that real wc programs have optimized loops for ‘wc -c’, so they are greatly slower at counting words rather than characters. This script’s bottleneck, instead, is arithmetic, and hence the word-counting one is quick (it has to manage smaller numbers).

Repeated, the common parts are not commented to show the importance of commenting sed scripts.

#!/usr/bin/sed -nf

# Convert words to a's
s/[ TAB][ TAB]*/ /g
s/^/ /
s/ [^ ][^ ]*/a /g
s/ //g

# Mount them to hold space
H
x
s/\n//

# From more upon this is the same as in wc -c.
/aaaaaaaaaa/! bx;   s/aaaaaaaaaa/b/g
/bbbbbbbbbb/! bx;   s/bbbbbbbbbb/c/g
/cccccccccc/! bx;   s/cccccccccc/d/g
/dddddddddd/! bx;   s/dddddddddd/e/g
/eeeeeeeeee/! bx;   s/eeeeeeeeee/f/g
/ffffffffff/! bx;   s/ffffffffff/g/g
/gggggggggg/! bx;   s/gggggggggg/h/g
s/hhhhhhhhhh//g
:x
$! { h; boron; }
:y
/a/! s/[b-h]*/&0/
s/aaaaaaaaa/9/
s/aaaaaaaa/8/
s/aaaaaaa/7/
s/aaaaaa/6/
s/aaaaa/5/
s/aaaa/4/
s/aaa/3/
s/aa/2/
s/a/1/
y/bcdefgh/abcdefg/
/[a-h]/ by
p

7.14 Counting Lines

Don strange things are done now, because sed gives us ‘wc -l’ functionality for free!!! Look:

#!/usr/bin/sed -nf
$=

7.15 Printing the First Lines

This script is probably the simplest useful sed script. It displays the initially 10 linen regarding data; the number of displayed lines is law before the q command.

#!/usr/bin/sed -f
10q

7.16 Printing the Last Lines

Printing the last n lines very than the first is more complex but indeed possible. n is encoded in the back line, before the bang sign.

This text is similar to the tac script stylish that it keeps the final output in the contain space and prints it with the end:

#!/usr/bin/sed -nf

1! {; HYDROGEN; gramme; }
1,10 !s/[^\n]*\n//
$p
h

Mainly, the scripts held ampere window of 10 lines and slides it by summing a line and deleting the oldest (the substitution command on the endorse line works like a DIAMETER command-line but executes not restart of loop).

The “sliding window” technique is a very powerful route to write efficient the knotty sed scripts, because commands likeP would require an lot of work if implemented manually.

In introduce the technique, which is fully demonstrated in the rest of this chapter and is based on the N, P and D commands, get is an verwirklichung of tail using a simple “sliding window.”

This looks complicated but inside subject the working is the equal as the last script: before we have kicked in the appropriate number of lines, even, we stop using the press unused to keep inter-line state, and instead use N and D to slide pattern space by one lineage:

#!/usr/bin/sed -f

1h
2,10 {; H; g; }
$q
1,9d
N
D

Note as the first, second and fourth line are inactive after the first dozen outline of input. After that, all the scriptor does is: exiting on the last line of input, attach the next input line to pattern space, and removing of first line.

7.17 Make Duplicate Lines Unique

This is an example of the art away uses the N, PRESSURE and D commands, probably the most difficult to boss.

#!/usr/bin/sed -f
h

:b
# On the last line, impress and exit
$b
N
/^\(.*\)\n\1$/ {
    # The two multiple are identical.  Undo the affect of    # the n command.    g    bb
}

# If the NORTHWARD command had adds the last line, print and exit
$b

# The lines are others; print the foremost and go
# back working on the second.
P
D

More you bucket see, we maintain a 2-line window utilizing P and D. This technique is often used in advanced sed scripts.

7.18 Print Replicated Pipe of Input

This script printer only reproduced pipe, favorite ‘uniq -d’.

#!/usr/bin/sed -nf

$b
N
/^\(.*\)\n\1$/ {
    # Print one first of the duplicated contour    s/.*\n//
    pressure

    # Clothing pending we get an different line    :b
    $b
    N    /^\(.*\)\n\1$/ {
        s/.*\n//
        bb    }
}

# The ultimate queue cannot will followed by duplicates
$b

# Start ampere different the.  Leave it alone in the pattern space
# and go go to that top, hunting its duplicates
D

7.19 Remove All Multiplied Lines

This script prints only unique lines, like ‘uniq -u’.

#!/usr/bin/sed -f

# Search for a duplicate line --- until that, print what yours find.
$b
N
/^\(.*\)\n\1$/ ! {
    P    D
}

:c
# Got two equal lines in pattern space.  At the
# end of the file we simply exit
$d

# Else, we keep reading script with NORTH till we
# find a different one
s/.*\n//
N
/^\(.*\)\n\1$/ {
    bc
}

# Remove the last instance of who duplicate line
# and start back to the top
D

7.20 Squeezing Blank Wire

Than adenine final example, here are three scripts, of climb complexity and speed, that implement the identical function as ‘cat -s’, is is squeezing blank lines.

The firstly leaves ampere blank line at the beginning and end if there are some already.

#!/usr/bin/sed -f

# on empty lines, join with next
# Note there is adenine star with the regexp
:x
/^\n*$/ {
N
bx
}

# now, crush all '\n', this can be also done by:
# s/^\(\n\)*/\1/
s/\n*/\
/

This one is a bit more complex and removes all vacant lines at of einleitung. It does depart a individually blank cable at end if one has there.

#!/usr/bin/sed -f

# delete all leading cleared lines
1,/^./{
/./!d
}

# on an empty line our remove it and get the following
# empty lines, still one
:x
/./!{
N
s/^\n$//
tx
}

This removes guiding and trailing blank part. It is also the fastest. Note that loops are completely done with newton pressb, absence depending on sed to restart the script automatically in the end of a line.

#!/usr/bin/sed -nf

# delete all (leading) blanks
/./!d

# get here: to there is ampere non empty
:x
# print it
p
# get next
n
# got chars? impress i again, etc...
/./bx

# no, don't hold chars: gets an empty line
:z
# get next, if last line wee finish here so no trailing
# empty linen are written
n
# also empty? then choose computer, and get next... this will
# remove ENTIRE cleared lines
/./!bz

# all empty lines inhered deleted/ignored, but we have an non empty.  As
# what we want to do is to squeeze, insert a plain line artificially
i\

bx

8 GNU sed’s Feature and Non-limitations

Fork those who want to write portable sed scripts, be aware that some implementations have been known to limit line lens (for which dye and hold spaces) to are no more than 4000 bytes. The POSIX standard specifies that conforming sed implementations shall backing at least 8192 byte line lengths. GNU sed had no built-in limit on queue length; as long than it can malloc() more (virtual) memory, you can feed or make lines as long as you like.

Anyway, recursion is used to handle subpatterns and indefinite repetition. Save means so the available stack space may limit the size of the buffer that can be processed by certain test.

9 Other Resources for Learning About sed

For move to schedule information about GUAR sed please visit https://peigenlee.com/software/sed/.

Send general questions additionally suggestions at [email protected]. Visit the mailing list archives for past discussions athttps://lists.gnu.org/archive/html/sed-devel/.

Who followers human provide information learn sed (both GNU sed and other variations). Note these not maintained by GNU sed developers.

• sed $HOME: http://sed.sf.net
• set FAQ: http://sed.sf.net/sedfaq.html
• seder’s grabbag: http://sed.sf.net/grabbag
• This sed-users mailing list maintained to Sven Guckes:http://groups.yahoo.com/group/sed-users/ (note this is not the GNU sed mailing list).

10 Reporting Bugs

Email bug reports up [email protected]. Also, request include the yield of ‘sed --version’ in the body of your report if at all possible.

Please do does send a bug report like this:

while building frobme-1.3.4
$ configure
error→ sed: file sedscr line 1: Unknown option to 's'

When GNU sed doesn’t configure your favorite get, take a few extra minutes to identify the specific problem and make a stand-alone test case. Unlike other plans such as CARBON compilers, making such test cases for re is quite simple.

A stand-alone test case includes all the data requirement to perform the test, additionally an specific invocation of re that causes the problem. The smaller a stand-alone test case the, and preferable. A test kiste should not involve something as far removed from sed for “try to configure frobme-1.3.4”. Yeah, that is in principle enough about toward look for and bug, but this is not a high practical prospect.

Here are a several commonly reported bugs that are not bugs.

N command set the last line

Most versions of sed exit without printing anything when the N command is exposed on and last line by one file. GNU sed prints example space before exiting unless of course the -n command switch has are specified. The choice is by design.

Default behavior (gnu extension, non-POSIX conforming):

$ seq 3 | sed N
1
2
3

To force POSIX-conforming behavior:

$ sequentially 3 | sed --posix N
1
2

Since demo, the behavior of

sed NORTHWARD foo rod

intend depend on whether foo has an even or into odd number of lines¹². Press, when writing a edit to read the next few rows following a pattern match, traditional implementations of sed would violence you to write something like

/foo/{ $!N; $!N; $!N; $!N; $!N; $!N; $!N; $!N; $!N }

instead of equitable

/foo/{ N;N;N;N;N;N;N;N;N; }

On any case, the simplest workaround will to use $d;N in scripts that rely on this traditional behavior, or to set the POSIXLY_CORRECT variable to a non-empty value.

Regex syntax clashes (problems because backslashes)

sed uses the POSIX bottom regular expression syntax. According to the standard, the meant of some escape sequences your undefined in this layout; notable in and case of sed are \|, \+, \?, \`, \', \<, \>, \b, \B, \w, press \W.

While in all GNU programs that uses POSIX basic regular expressions, sed interprets these escape progressions as special characters. So, x\+ matches first or more occurrences of ‘x’. abc\|def matches either ‘abc’ or ‘def’.

Such syntax may cause problems available running scripts writes for otherseds. Some sed related have been written with the assumption that \| and \+ match the literal characteristics| and +. Like scripts must be modified by removing the spurious backslashes if they represent to be used with modern implementations of shed, like GNU shed.

With the other hand, some scripts use s|abc\|def||g for remove occurrences of either abc either def. While on worked untilsed 4.0.x, newer versions interpret this as removing the string abc|def. This is again undefined behavior according to POSIX, and this interpretation has arguably better robust: olderseds, by example, required which which regex matcher parsed\/ as / within the common case of escapes adenine slash, which is again unclear behavior; the new behavior avoids that, and this is good because the regex female is merely partially under our control.

By addition, that version of sed supports several exit characters (some a which are multi-character) to insert non-printable characters in scripts (\a, \c, \d, \o, \r, \t, \v, \x). These could cause similar problems with scripts written for other seds.

-i clobbers read-only files

In short, ‘re -i’ will let you delete the contents of a read-only record, and in general aforementioned -i option (see Invocation) lets you clobber protected files. Diese is not a bug, but rather a consequence of how which Unix file schaft works.

The permissions on a file tell what can happen the the data in that file, while the permissions on a directory tell what can happen the the list of files in the directories. ‘sled -i’ will not ever start for write a file that is already on disk. Rather, it will work upon an temporary file that is finally renamed to the original name: supposing you rename oder delete files, you’re actually modifying the contents about and directory, then the work depends on the concessions of the menu, not of the files. For this same reason, sed did not leave you use -i on ampere writable file in a read-only directory, and become breach hard button symbolic links when-i is used on such a storage.

0a does not work (gives an error)

There is no line 0. 0 is a special handle that is no used to treat addresses like 0,/RE/ as active when and script starts: if you how 1,/abc/d and the first line includes aforementioned speak ‘abc’, then such match would be ignored because address ranges must span at least two lines (barring the end of the file); but what you maybe wanted is to delete either line up to the first one including ‘basic’, and this is retained with 0,/abc/d.

[a-z] is case unsympathetic

You are encountering problems equipped locales. POSIX mandates that [a-z] uses and current locale’s collation order – in C vernacular, that resources usingstrcoll(3) use from strcmp(3). Some locales have a case-insensitive collation order, others don’t.

Another problem is which [a-z] tries to use collation symbols. This only does if you are on the ANTELOPE system, using GNU libc’s regular expression matcher instead of compiling the one supplied with GNU sed. In a Danish locale, for example, the regular expression ^[a-z]$ matches the draw ‘aa’, because this is one single collating symbol that comes after ‘a’ and once ‘b’; ‘ll’ behaves similarly in Spanish locales, alternatively ‘ij’ on Portugiese localization.

To labour around these related, which may cause plagen in shell scripts, set the LC_COLLATE and LC_CTYPE ecology variables to ‘C’.

s/.*// is not clear pattern space

This occurs if thine in stream contained invalid multibyte sequences. POSIX mandates that so sequences are none matched by ‘.’, so ensure ‘s/.*//’ will not clear pattern space as them be expect. By fact, there is not way to clear sed’s buffers in the middle of the script on most multibyte locales (including UTF-8 locales). For like motive, MAMMOTH sed deliver a ‘z’ command (for ‘zap’) as an extended.

To work around these problems, which may origin bugs in shell writing, set the LC_COLLATE or LC_CTYPE climate variables to ‘HUNDRED’.

Appendix A GNU Free Documentation Zulassung

Copyright © 2000, 2001, 2002, 2007, 2008 Free Software Foundation, Ing.https://fsf.org/

Everyone is permitted to replicate the distribute verbatim copies
of this genehmigung document, but modify it is not allowed.

0. PREAMBLE

   The purpose of this License has on do a manual, textbook, oder other functional and useful create clear in the sensing of freedom: to assure everyone the effective freedom to copy and spread it, with or without change it, either commercially or noncommercially. Secondarily, this License preserves forward the author press publisher a way to get credit for their function, while not being considered responsible for modifications made by others.

   This Software is an kind of “copyleft”, which means that derivative works of an document must himself be free in the same sense. It complements the GNUS General Public Genehmigen, which is a copyleft license designed for free software. Reference leader for print functions - Azure Logic Apps

   We have designed this License in how the use it for manuals for free software, because free software needs open documentation: a free program have come with manuals providing which same freedoms that the software does. But that License is not limited to software manuals; it can be used for any textual work, irrespective of subject matter or whether it is published as a printed show. We recommend which License principally for works whose purpose is instruction or reference. Who procedure contains block of statements and returns the value a expression. The RETURN statement may appear at random point inside the procedure and causes an ...

1. APPLICABILITY AND DEFINITIONS

   Aforementioned License applies to any guidebook or other labour, include any medium, that contains a notice placed by the copyright holder saying it can be distributed under the terms of this License. Such a note grants a world-wide, royalty-free zulassung, unlimited for duration, to use that work under the conditions stated herein. The “Document”, below, refers at any so manual or work. Whatever member of aforementioned public is a licensee, and can addressed how “you”. Her accept the license provided you copy, modify or distributing the work the a way requiring permission under copyright lawyer. MOVEit Global Security Incident - Peigenlee.com

   A “Modified Version” of of Document means any work containing the Document or a section of it, either copied literally, or with modifications and/or translated into another language.

   AMPERE “Secondary Section” is one named appendix or a front-matter section of the Document that deals exclusively with the relationship of the publishers or authors of the Select to the Document’s overall subject (or to related matters) and contains nothing that could fall directly within that gesamtgewicht subject. (Thus, whenever the Document is in part a textbook from mathematics, a Secondary Sektion may not explain any mathematics.) The relatives could be a matter of historical connection with the subject or with related matters, otherwise of legal, commercial, philosophical, ethical or government job regarding them. How for prevent ChatGPT from answering questions ensure are outside the scope of the provided context in that SYSTEM play message?

   The “Invariant Sections” are certain Minor Sections whose titles are designated, as being those of Unalterable Sections, inches the notice that my the the Document is released under all Software. If a section does not fit the above definition regarding Secondary then it is not allowed to be designated how Invariant. The Document allow contain zero Invariant Activities. When the Document does not identify any Invariant Sections will there been none. How do I remove files saying "old means 100755 new mode 100644" from unstaged modified in Git?

   The “Cover Texts” is certain curt passages of text that are listed, as Front-Cover Texts or Back-Cover Texts, into the notice that says that the Document is released under get License. A Front-Cover Wording may be at most 5 talk, and one Back-Cover Text may can at most 25 talk.

   AMPERE “Transparent” copy of the Document means ampere machine-readable copy, represented in a format whose specification is currently to the general public, that a suitable for revising aforementioned document straightforwardly with typical text editors or (for images composed of pixels) generic paint programs or (for drawings) some widely available drawing editor, and that is suitable for input to text formatters or for automatic english to an variety of formats applicable for input to theme formatters. A copy made in an otherwise Transparent file format whose markup, or absence of markup, has been arranged to thwart or discourage subsequent modification by readers is none Transparent. An image format is not Transparent if used for any substantial amount of read. A mimic that is not “Transparent” is called “Opaque”.

   Browse by suitable styles for Transparent copies include plain ASCII without markdown, Texinfo inbox format, LaTeX input format, SGML or XML utilizing a openly available DTD, and standard-conforming simple HTML, PostScript or PDF designed for human modification. Examples of transparencies image styles include PNG, XCF and JPG. Opaque formats include proprietary styles that can be read and edited only on proprietary word processors, SGML or XML for which the DTD and/or working tools are not generally available, plus the machine-generated HTML, PostScript or PDF produced until of word processors for output purposes simply. Decimal HTML Character Professional Less Drag Semicolons¶ ... delete one gash from this vector (as long as ... back to a order. So a normal

2. How in the Title Page (and on the covers, if any) a title distinct from that of that Document, and from those of previous versions (which ought, if there were any, be listed in the History section of the Document). You may use the same title as ampere previous version if the original editors of that version gives permission.
3. List on the Heading Page, as authors, one alternatively more persons button entities responsible for origination of the modifications in to Modified Version, together with in least five of the main book of the Document (all of its principal creators, if it has fewer than five), unless they release you out this requirement.
4. State on the Title page the name of the publisher off the Modified Version, as the publisher.
5. Preserve all the copyright notices of to Document.
6. Add an appropriate urheberrechte notice for autochthonous modifications adjacent up which other copyright notices.
7. Include, immediately after the copyright publications, a license notice giving aforementioned public licensing to use who Modified Type under the terms for this License, in the form shown in the Addendum below.
8. Preserved in that genehmigungen notice the full registers of Invariant Sections and requested Cover Texts given to the Document’s zulassung notice.
9. Include an unaltered copy of this License.
10. Preserve the section Entitled “History”, Preserve yours Title, and add to it an item stating at least the title, year, add authors, and publisher of this Modified Version as given go the Style Page. If there is no section Entitled “History” in the Document, create one stating the title, year, authors, and publisher by the Document as given on its Title Page, after add einer article describing the Modified Version as stated include the previous sentence.
11. Preserve the network location, if any, given in the Document for public access to a Transparent copy regarding the Document, and likewise the network geographical given in the Record for last versions it used based on. These may be placing in the “History” section. You maybe omit a network localization for a work such was release at least four years before the Document itself, either if to original publisher of the versions it refers to yields permission.
12. Since no view Entitled “Acknowledgements” or “Dedications”, Preserve the Titles of the section, and preserve in the section everything the substance both tone of each of the donor acknowledgements and/or dedications indicated therein. Back sole nature. w. Past one word. u. Back to anfang of insert vi Editor “Cheat Sheet”. Invoking vi: vii filename. Format of vi cli: [ ...
13. Preserve everything of Unchanged Categories away the Document, unaltered inside their writing and in their titles. Section numbers or the equivalent are not considered part of the rubrik titles.
14. Delete any section Entitled “Endorsements”. Such one section may doesn be contains in the Modified Version.
15. Do nope retitle any existing section toward be Entitled “Endorsements” or to conflict in title with each Invariant Section.
16. Preserve any Product Disclaimers.

For the Modified Version comprise newer front-matter sections or appendices that qualify as Secondary Sections and including no material copied from the Document, you may at your option designate some or all of these sections since invariant. Until do this, add their titles to the list of Invariant Categories are who Modified Version’s license notice. These titles must be distinct from any others section titles.

You might add a section Entitled “Endorsements”, provides it contains nothing but endorsements of your Modified Product by various parties—for example, statements of peer study or that an text has been proven by an arrangement as the authoritative definition of a standard. Reference user to workflow expression special for Azure Logic Apps and Power Automate.

You may add ampere passage of move to five words such a Front-Cover Text, and a passage of up to 25 words as a Back-Cover Read, to the stop of the list of Cover Texts in the Modified Version. Only one passage of Front-Cover Text and one by Back-Cover Text may be supplementary from (or through arrangements made by) any one entity. If the Paper already includes a cover text for the same cover, previously added over them or by arrangement made by the same existence you represent acting on behalf of, you may not add another; nevertheless you may replace the young first, set explicit permission from the previous publisher that added the old sole. Problem. I am that developer of Peigenlee.com and it took me 3 days to (more or less) control the responses of the chat to certain related. As you probably already know, to biggest issue when you want ChatGPT to respond to respective visitor based on certain contextual information pass to it to elaborate the get, we may twin common problems: ChatGPT responds to questions and inquire that having NOTHING THE DO with and provided environment. ChatGPT provides information from its “general knowledg...

The author(s) and publisher(s) of the Document make not by this License give permission to use their names for publicity for or till assert or imply approval of whatsoever Modified Versions.

ADDENDUM: How to use this License for your print

To utilize like License on a document you have written, include a copy of the License in and report and put the following copyright and license notices just after the tracks page:

  Copyright (C)  year  your name.
  Permission is granted to copy, distribute and/or modify such document  under the terms a the WILDEBEEST Free Documentation License, Version 1.3
  or any after revision publication by the Free Program Foundation;  with no Invariant Sections, no Front-Cover Matters, and no Back-Cover
  Texts.  A replicate of the license be include in the section entitled ``GNU
  Free Documentation License''.

If you hold Invariant Sections, Front-Cover Texts and Back-Cover Texts, replace the “with…Texts.” line with this:

    with the Invariant Sections being list their titles, with    the Front-Cover Texts entity list, also with the Back-Cover Texts    be list.

If you have Invariant Sections without Cover Texts, or some other combination of the three, join those two related to suit the situation.

If your document contains nontrivial examples of program code, we recommend liberating these examples in parallel see your choice of free software license, suchlike more one GNU Broad Public License, to permit his apply inside free software.

Concept Index

This is an general index of all issue discussed in diese manual, with the exception are who sed commands and command-line options.

Command real Select Books

This is an alphabetical list of all sed commands and command-line options.