Explore topic-wise InterviewSolutions in .

Most versions of sed do not, but CHECK the documentation that CAME with whichever version you are using. GNU sed ISSUES an EXIT code of 0 if the program terminated normally, 1 if there were errors in the SCRIPT, and 2 if there were errors during script execution.

Most versions of sed do not, but check the documentation that came with whichever version you are using. GNU sed issues an exit code of 0 if the program terminated normally, 1 if there were errors in the script, and 2 if there were errors during script execution.

TRY entering "sed" all by itself on the command line, FOLLOWED by no arguments or parameters. ALSO, try "sed --version". In a pinch, you can also try this:

strings sed | grep -i ver

Your version of 'strings' must be a version of the UNIX utility of this name. It should not be the DOS utility STRINGS.COM by Douglas Boling.

Try entering "sed" all by itself on the command line, followed by no arguments or parameters. Also, try "sed --version". In a pinch, you can also try this:

strings sed | grep -i ver

Your version of 'strings' must be a version of the Unix utility of this name. It should not be the DOS utility STRINGS.COM by Douglas Boling.

Prior to GNU SED v3.02, there weren't any. Until recently, man pages DISTRIBUTED with gsed were borrowed from old sources or from other COMPILATIONS. None of them were "official." GNU sed v3.02 had the first real set of official man pages, and the documentation has greatly improved with GNU sed version 4.0, which now includes both man pages and textinfo pages.

Prior to GNU sed v3.02, there weren't any. Until recently, man pages distributed with gsed were borrowed from old sources or from other compilations. None of them were "official." GNU sed v3.02 had the first real set of official man pages, and the documentation has greatly improved with GNU sed version 4.0, which now includes both man pages and textinfo pages.

Because your sed script uses 'SINGLE quotes' instead of "DOUBLE quotes." Unix SHELLS never EXPAND $VARIABLES in single quotes.

Because your sed script uses 'single quotes' instead of "double quotes." Unix shells never expand $variables in single quotes.

Technically, the normal meaning of the slash can be disabled by PREFIXING it with a BACKSLASH. Thus,

sed 's//some/UNIX/path//a/new/path/g' files

But this is hard to read and write. There is a BETTER solution. The s/// SUBSTITUTION command allows '/' to be replaced by any other character (INCLUDING spaces or alphanumerics). Thus,

sed 's|/some/UNIX/path|/a/new/path|g' files

and if you are using variable names in a Unix shell script,

sed "s|$OLDPATH|$NEWPATH|g" oldfile >newfile

Technically, the normal meaning of the slash can be disabled by prefixing it with a backslash. Thus,

sed 's//some/UNIX/path//a/new/path/g' files

But this is hard to read and write. There is a better solution. The s/// substitution command allows '/' to be replaced by any other character (including spaces or alphanumerics). Thus,

sed 's|/some/UNIX/path|/a/new/path|g' files

and if you are using variable names in a Unix shell script,

sed "s|$OLDPATH|$NEWPATH|g" oldfile >newfile

SUPPOSE that line #1, word #2 of the file 'terminals' contains a VALUE to be put in your TERM environment variable. Sed cannot export variables directly to the SHELL, but it can pass strings to shell commands. To SET a variable in the Bourne

shell:TERM=`sed 's/^[^ ][^ ]* ([^ ][^ ]*).*/1/;q' terminals`;
export TERM

If the second word were "Wyse50", this would send the shell command "TERM=Wyse50".

Suppose that line #1, word #2 of the file 'terminals' contains a value to be put in your TERM environment variable. Sed cannot export variables directly to the shell, but it can pass strings to shell commands. To set a variable in the Bourne

shell:TERM=`sed 's/^[^ ][^ ]* ([^ ][^ ]*).*/1/;q' terminals`;
export TERM

If the second word were "Wyse50", this would send the shell command "TERM=Wyse50".

A frequent request is how to convert DOS-style textfiles, in which each line ends with "paragraph marker", to Microsoft-style textfiles, in which the "paragraph" marker only appears at the end of real paragraphs. Sometimes this question is framed as, "How do I remove the HARD returns at the end of each line in a paragraph?"

The problem occurs because newer word processors don't work the same way older text editors did. Older text editors used a newline (CR/LF in DOS; LF alone in Unix) to end each line on screen or on disk, and used two newlines to separate paragraphs. Certain word processors wanted to make paragraph reformatting and reflowing work easily, so they use one newline to end a paragraph and never allow newlines within a paragraph. This means that textfiles created with standard editors (Emacs, vi, Vedit, Boxer, etc.) appear to have "hard returns" at inappropriate places. The following sed script finds blocks of consecutive nonblank lines (i.e., paragraphs of text), and converts each block into one long line with one "hard return" at the end.

# sed script to change all paragraphs to long lines
/./{H; $!d;} # Put each paragraph into hold space
X; # Swap hold space and pattern space
 s/^(n)(..*)$/21/; # Move leading n to end of PatSpace
 s/n(.)/ 1/g; # Replace all other n with 1 space
# Uncomment the following line to remove excess blank lines:
# /./!d;
#---end of sed script---

If the input files have FORMATTING or indentation that conveys SPECIAL meaning (like program source code), this script will remove it. But if the text STILL needs to be extended, try 'par' (paragraph reformatter) or the 'fmt' utility with the -t or -c switches and the width option (-w) set to a number like 9999.

A frequent request is how to convert DOS-style textfiles, in which each line ends with "paragraph marker", to Microsoft-style textfiles, in which the "paragraph" marker only appears at the end of real paragraphs. Sometimes this question is framed as, "How do I remove the hard returns at the end of each line in a paragraph?"

The problem occurs because newer word processors don't work the same way older text editors did. Older text editors used a newline (CR/LF in DOS; LF alone in Unix) to end each line on screen or on disk, and used two newlines to separate paragraphs. Certain word processors wanted to make paragraph reformatting and reflowing work easily, so they use one newline to end a paragraph and never allow newlines within a paragraph. This means that textfiles created with standard editors (Emacs, vi, Vedit, Boxer, etc.) appear to have "hard returns" at inappropriate places. The following sed script finds blocks of consecutive nonblank lines (i.e., paragraphs of text), and converts each block into one long line with one "hard return" at the end.

# sed script to change all paragraphs to long lines
/./{H; $!d;} # Put each paragraph into hold space
x; # Swap hold space and pattern space
 s/^(n)(..*)$/21/; # Move leading n to end of PatSpace
 s/n(.)/ 1/g; # Replace all other n with 1 space
# Uncomment the following line to remove excess blank lines:
# /./!d;
#---end of sed script---

If the input files have formatting or indentation that conveys special meaning (like program source code), this script will remove it. But if the text still needs to be extended, try 'par' (paragraph reformatter) or the 'fmt' utility with the -t or -c switches and the width option (-w) set to a number like 9999.

Suppose a line begins with a particular string. How do you bring that line up to follow the previous line In this example, we want to match the string "&LT;<=" at the BEGINNING of one line, bring that line up to the end of the line before it, and REPLACE the string with a single space:

SED -E :a -e '$!N;s/n<<=/ /;ta' -e 'P;D' file # all seds
sed ':a; $!N;s/n<<=/ /;ta;P;D' file # GNU, ssed, sed15+

Suppose a line begins with a particular string. How do you bring that line up to follow the previous line In this example, we want to match the string "<<=" at the beginning of one line, bring that line up to the end of the line before it, and replace the string with a single space:

sed -e :a -e '$!N;s/n<<=/ /;ta' -e 'P;D' file # all seds
sed ':a; $!N;s/n<<=/ /;ta;P;D' file # GNU, ssed, sed15+

SED -e :a -e '/\$/N; s/\n//; ta' FILE # all seds
sed ':a; /\$/N; s/\n//; ta' file # GNU sed, ssed, HHsed

Note that this replaces the backslash-newline with nothing. You may want to replace the backslash-newline with a single space instead.

sed -e :a -e '/\$/N; s/\n//; ta' file # all seds
sed ':a; /\$/N; s/\n//; ta' file # GNU sed, ssed, HHsed

Note that this replaces the backslash-newline with nothing. You may want to replace the backslash-newline with a single space instead.

Normally, to address the lines between two regular expressions, RE1 and RE2, one would do this: '/RE1/,/RE2/{commands;}'. Excluding those lines TAKES an extra step. To put 2 arrows before each line between RE1 and RE2, except for those lines:

sed '1,/RE1/!{ /RE2/,/RE1/!s/^/>>/; }' input.fil

The preceding script, though short, MAY be DIFFICULT to follow. It also requires that /RE1/ cannot occur on the first line of the input file. The following script, though it's not a one-liner, is easier to read and it permits /RE1/ to appear on the first line:

# sed script to replace all lines between /RE1/ and /RE2/,
# without matching /RE1/ or /RE2/
/RE1/,/RE2/{
/RE1/b
/RE2/b
s/^/>>/
}
#---END of script---

Normally, to address the lines between two regular expressions, RE1 and RE2, one would do this: '/RE1/,/RE2/{commands;}'. Excluding those lines takes an extra step. To put 2 arrows before each line between RE1 and RE2, except for those lines:

sed '1,/RE1/!{ /RE2/,/RE1/!s/^/>>/; }' input.fil

The preceding script, though short, may be difficult to follow. It also requires that /RE1/ cannot occur on the first line of the input file. The following script, though it's not a one-liner, is easier to read and it permits /RE1/ to appear on the first line:

# sed script to replace all lines between /RE1/ and /RE2/,
# without matching /RE1/ or /RE2/
/RE1/,/RE2/{
/RE1/b
/RE2/b
s/^/>>/
}
#---end of script---

There are three ways to approach this problem:

1. TRY to use a "/range/, /EXPRESSION/"
2. Try to use a "/multi-linenexpression/"
3. Try to use a block of "LITERAL STRINGS"

We describe each approach in the following sections.

There are three ways to approach this problem:

We describe each approach in the following sections.

Assume that PARAGRAPHS are SEPARATED by blank lines. For regexes that are SINGLE terms, use one of the following scripts:

 sed -e '/./{H;$!d;}' -e 'x;/REGEX/!d' # most seds
sed '/./{H;$!d;};x;/regex/!d' # GNU sed

To print paragraphs only if they contain 3 specific regular EXPRESSIONS (RE1, RE2, and RE3), in any order in the paragraph:

sed -e '/./{H;$!d;}' -e 'x;/RE1/!d;/RE2/!d;/RE3/!d'

With this solution and the preceding one, if the paragraphs are excessively long (more than 4k in length), you may overflow sed's internal buffers.

Assume that paragraphs are separated by blank lines. For regexes that are single terms, use one of the following scripts:

 sed -e '/./{H;$!d;}' -e 'x;/regex/!d' # most seds
sed '/./{H;$!d;};x;/regex/!d' # GNU sed

To print paragraphs only if they contain 3 specific regular expressions (RE1, RE2, and RE3), in any order in the paragraph:

sed -e '/./{H;$!d;}' -e 'x;/RE1/!d;/RE2/!d;/RE3/!d'

With this solution and the preceding one, if the paragraphs are excessively long (more than 4k in length), you may overflow sed's internal buffers.

The FOLLOWING deletes the block between 'start' and 'end' inclusively, if and only if the block contains the string 'REGEX'. Written by Russell Davies, with additional comments:

# sed script to delete a block if /regex/ matches inside it
:t
/start/,/end/ { # For each line between these block markers..
/end/!{ # If we are not at the /end/ marker
$!{ # nor the last line of the file,
N; # add the Next line to the pattern space
bt
} # and branch (loop back) to the :t label.
} # This line matches the /end/ marker.
/regex/d; # If /regex/ matches, delete the block.
} # Otherwise, the block will be printed.
#---end of script---

Note: When the script above reaches /regex/, the entire multi-line block is in the pattern space. To replace ITEMS inside the block, use "s///". To change the entire block, use the 'C' (change) command:

/regex/c
1: This will replace the entire block
2: with these two lines of text.

The following deletes the block between 'start' and 'end' inclusively, if and only if the block contains the string 'regex'. Written by Russell Davies, with additional comments:

# sed script to delete a block if /regex/ matches inside it
:t
/start/,/end/ { # For each line between these block markers..
/end/!{ # If we are not at the /end/ marker
$!{ # nor the last line of the file,
N; # add the Next line to the pattern space
bt
} # and branch (loop back) to the :t label.
} # This line matches the /end/ marker.
/regex/d; # If /regex/ matches, delete the block.
} # Otherwise, the block will be printed.
#---end of script---

Note: When the script above reaches /regex/, the entire multi-line block is in the pattern space. To replace items inside the block, use "s///". To change the entire block, use the 'c' (change) command:

/regex/c
1: This will replace the entire block
2: with these two lines of text.

You can match a RANGE of LINES by line number, by regexes (say, all lines between the WORDS "from" and "until"), or by a combination of the two. For multiple substitutions on the same range, put the command(s) between braces {...}.

For example:

# replace only between lines 1 and 20
1,20 s/Johnson/White/g

# replace everywhere EXCEPT between lines 1 and 20
1,20 !s/Johnson/White/g

# replace only between words "from" and "until". Note the
# use of as word boundary markers in GNU sed.
/from/,/until/ { s//magenta/g; s//cyan/g; }

# replace only from the words "ENDNOTES:" to the end of FILE
/ENDNOTES:/,$ { s/Schaff/Herzog/g; s/Kraft/Ebbing/g; }

You can match a range of lines by line number, by regexes (say, all lines between the words "from" and "until"), or by a combination of the two. For multiple substitutions on the same range, put the command(s) between braces {...}.

For example:

# replace only between lines 1 and 20
1,20 s/Johnson/White/g

# replace everywhere EXCEPT between lines 1 and 20
1,20 !s/Johnson/White/g

# replace only between words "from" and "until". Note the
# use of as word boundary markers in GNU sed.
/from/,/until/ { s//magenta/g; s//cyan/g; }

# replace only from the words "ENDNOTES:" to the end of file
/ENDNOTES:/,$ { s/Schaff/Herzog/g; s/Kraft/Ebbing/g; }

Sed handles fixed-length fields via (grouping) and backreferences (1, 2, 3 ...). If we have 3 fields of 10, 25, and 9 CHARACTERS per FIELD, our sed script might look like so:

 s/^(.{10})(.{25})(.{9})/321/; # Change the fields
^^^^^^^^^^^~~~~~~~~~~~========== # from 1,2,3 to 3,2,1
field #1 field #2 field #3

This is a bit hard to read. By using GNU sed or ssed with the -r switch ACTIVE, it can look like this:

 s/^(.{10})(.{25})(.{9})/321/; # Using the -r switch

To delete a field in sed, use grouping and omit the backreference from the field to be deleted. If the data is long or difficult to work with, use ssed with the -R switch and the /x flag after an s/// command, to insert comments and remarks about the fields.

For records with many fields, use GNU AWK with the FIELDWIDTHS variable set in the top of the script. For EXAMPLE:

awk 'BEGIN{FIELDWIDTHS = "10 25 9"}; {print $3 $2 $1}' file

This is much easier to read than a similar sed script, especially if there are more than 5 or 6 fields to manipulate.

Sed handles fixed-length fields via (grouping) and backreferences (1, 2, 3 ...). If we have 3 fields of 10, 25, and 9 characters per field, our sed script might look like so:

 s/^(.{10})(.{25})(.{9})/321/; # Change the fields
^^^^^^^^^^^~~~~~~~~~~~========== # from 1,2,3 to 3,2,1
field #1 field #2 field #3

This is a bit hard to read. By using GNU sed or ssed with the -r switch active, it can look like this:

 s/^(.{10})(.{25})(.{9})/321/; # Using the -r switch

To delete a field in sed, use grouping and omit the backreference from the field to be deleted. If the data is long or difficult to work with, use ssed with the -R switch and the /x flag after an s/// command, to insert comments and remarks about the fields.

For records with many fields, use GNU awk with the FIELDWIDTHS variable set in the top of the script. For example:

awk 'BEGIN{FIELDWIDTHS = "10 25 9"}; {print $3 $2 $1}' file

This is much easier to read than a similar sed script, especially if there are more than 5 or 6 fields to manipulate.

(1) The general solution is to use GNU sed or ssed, with ONE of these range expressions. The first script ("print only the first match") works with any version of sed:

sed -n '/RE/{p;Q;}' file # print only the first match
sed '0,/RE/{//d;}' file # delete only the first match
sed '0,/RE/s//to_that/' file # change only the first match

(2) If you cannot use GNU sed and if you know the pattern will not occur on the first line, this will work:

sed '1,/RE/{//d;}' file # delete only the first match
sed '1,/RE/s//to_that/' file # change only the first match

(3) If you cannot use GNU sed and the pattern might occur on the first line, use one of the following commands (credit for short GNU script goes to Donald Bruce Stewart):

sed '/RE/{X;/Y/!{s/^/Y/;h;d;};x;}' file # delete (one way)
sed -e '/RE/{d;:a' -e '$!N;$BA' -e '}' file # delete (another way)
sed '/RE/{d;:a;N;$ba;}' file # same script, GNU sed
sed -e '/RE/{s//to_that/;:a' -e '$!N;$!ba' -e '}' file # change

STILL another solution, using a flag in the hold space. This is portable to all seds and works if the pattern is on the first line:

# sed script to change "foo" to "bar" only on the first occurrence

1{x;s/^/first/;x;}
1,/foo/{x;/first/s///;x;s/foo/bar/;}
#---end of script---

(1) The general solution is to use GNU sed or ssed, with one of these range expressions. The first script ("print only the first match") works with any version of sed:

sed -n '/RE/{p;q;}' file # print only the first match
sed '0,/RE/{//d;}' file # delete only the first match
sed '0,/RE/s//to_that/' file # change only the first match

(2) If you cannot use GNU sed and if you know the pattern will not occur on the first line, this will work:

sed '1,/RE/{//d;}' file # delete only the first match
sed '1,/RE/s//to_that/' file # change only the first match

(3) If you cannot use GNU sed and the pattern might occur on the first line, use one of the following commands (credit for short GNU script goes to Donald Bruce Stewart):

sed '/RE/{x;/Y/!{s/^/Y/;h;d;};x;}' file # delete (one way)
sed -e '/RE/{d;:a' -e '$!N;$ba' -e '}' file # delete (another way)
sed '/RE/{d;:a;N;$ba;}' file # same script, GNU sed
sed -e '/RE/{s//to_that/;:a' -e '$!N;$!ba' -e '}' file # change

Still another solution, using a flag in the hold space. This is portable to all seds and works if the pattern is on the first line:

# sed script to change "foo" to "bar" only on the first occurrence

1{x;s/^/first/;x;}
1,/foo/{x;/first/s///;x;s/foo/bar/;}
#---end of script---

Several versions of sed support case-insensitive matching: ssed and GNU sed v3.02+ (with I flag after s/// or /regex/); sedmod with the -i switch; and sed16 (which supports both types of switches).

With other versions of sed, case-insensitive searching is awkward, so people may use awk or perl instead, since these programs have options for case-insensitive searches. In gawk/mawk, use "BEGIN {IGNORECASE=1}" and in perl, "/regex/i". For other seds, here are three solutions:

Solution 1: convert everything to upper case and search normally

# sed script, solution 1
h; # copy the original line to the hold space
# convert the pattern space to solid caps
 y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/
# now we can search for the word "CARLOS"
/CARLOS/ {
# add or insert lines. NOTE: "s/.../.../" will not WORK
# here because we are searching a modified pattern
# space and are not printing the pattern space.
}
x; # get back the original pattern space
# the original pattern space will be printed
#---END of sed script---

Solution 2: search for both cases

Often, proper names will EITHER start with all lower-case ("unix"), with an INITIAL capital letter ("Unix") or occur in solid caps ("UNIX"). There may be no need to search for every possibility.

/UNIX/b match
/[Uu]nix/b match
Solution 3: search for all possible cases
# If you must, search for any possible combination
/[Ca][Aa][Rr][Ll][Oo][Ss]/ { ... }

Bear in mind that as the pattern length increases, this solution becomes an order of magnitude slower than the one of Solution 1, at least with some implementations of sed.

Several versions of sed support case-insensitive matching: ssed and GNU sed v3.02+ (with I flag after s/// or /regex/); sedmod with the -i switch; and sed16 (which supports both types of switches).

With other versions of sed, case-insensitive searching is awkward, so people may use awk or perl instead, since these programs have options for case-insensitive searches. In gawk/mawk, use "BEGIN {IGNORECASE=1}" and in perl, "/regex/i". For other seds, here are three solutions:

Solution 1: convert everything to upper case and search normally

# sed script, solution 1
h; # copy the original line to the hold space
# convert the pattern space to solid caps
 y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/
# now we can search for the word "CARLOS"
/CARLOS/ {
# add or insert lines. Note: "s/.../.../" will not work
# here because we are searching a modified pattern
# space and are not printing the pattern space.
}
x; # get back the original pattern space
# the original pattern space will be printed
#---end of sed script---

Solution 2: search for both cases

Often, proper names will either start with all lower-case ("unix"), with an initial capital letter ("Unix") or occur in solid caps ("UNIX"). There may be no need to search for every possibility.

/UNIX/b match
/[Uu]nix/b match
Solution 3: search for all possible cases
# If you must, search for any possible combination
/[Ca][Aa][Rr][Ll][Oo][Ss]/ { ... }

Bear in mind that as the pattern length increases, this solution becomes an order of magnitude slower than the one of Solution 1, at least with some implementations of sed.

Input files, especially message-oriented text files, often contain toggle characters for emphasis, like ~this~, this, or =this=. Sed can make the same input pattern produce alternating OUTPUT each time it is encountered. Typical needs might be to generate HMTL codes or print codes for boldface, italic, or underscore. This script accomodates multiple occurrences of the toggle pattern on the same line, as well as cases where the pattern starts on one line and finishes several lines later, even at the end of the file:

# sed script to convert +this+ to [i]this[/i]
:a
/+/{ x; # If "+" is found, switch hold and pattern space
/^ON/{ # If "ON" is in the (former) hold space, then ..
s///; # .. delete it
x; # .. switch hold space and pattern space back
s|+|[/i]|; # .. turn the next "+" into "[/i]"
ba; # .. jump back to label :a and start over
}
s/^/ON/; # Else, "ON" was not in the hold space; create it
x; # Switch hold space and pattern space
s|+|[i]|; # Turn the first "+" into "[i]"
ba; # Branch to label :a to find ANOTHER pattern
}
#---end of script---

This script USES the hold space to create a "flag" to indicate whether the toggle is ON or not. We have added remarks to illustrate the script logic, but in most versions of sed remarks are not permitted after 'b'ranch commands or LABELS.

If you are sure that the +toggle+ characters never cross line boundaries (i.e., never begin on one line and end on another), this script can be REDUCED to one line:

s|+([^+][^+]*)+|[i]1[/i]|g

If your toggle pattern contains regex metacharacters (such as '*' or perhaps '+' or '?'), remember to quote them with backslashes.

Input files, especially message-oriented text files, often contain toggle characters for emphasis, like ~this~, this, or =this=. Sed can make the same input pattern produce alternating output each time it is encountered. Typical needs might be to generate HMTL codes or print codes for boldface, italic, or underscore. This script accomodates multiple occurrences of the toggle pattern on the same line, as well as cases where the pattern starts on one line and finishes several lines later, even at the end of the file:

# sed script to convert +this+ to [i]this[/i]
:a
/+/{ x; # If "+" is found, switch hold and pattern space
/^ON/{ # If "ON" is in the (former) hold space, then ..
s///; # .. delete it
x; # .. switch hold space and pattern space back
s|+|[/i]|; # .. turn the next "+" into "[/i]"
ba; # .. jump back to label :a and start over
}
s/^/ON/; # Else, "ON" was not in the hold space; create it
x; # Switch hold space and pattern space
s|+|[i]|; # Turn the first "+" into "[i]"
ba; # Branch to label :a to find another pattern
}
#---end of script---

This script uses the hold space to create a "flag" to indicate whether the toggle is ON or not. We have added remarks to illustrate the script logic, but in most versions of sed remarks are not permitted after 'b'ranch commands or labels.

If you are sure that the +toggle+ characters never cross line boundaries (i.e., never begin on one line and end on another), this script can be reduced to one line:

s|+([^+][^+]*)+|[i]1[/i]|g

If your toggle pattern contains regex metacharacters (such as '*' or perhaps '+' or '?'), remember to quote them with backslashes.

Several versions of sed support the notation xHH, where "HH" are two hex digits, 00-FF: ssed, GNU sed v3.02.80 and above, GNU sed v1.03, sed16 and sed15 (HHsed). Try to use one of those versions.

Sed is not intended to process binary or object code, and files which contain nulls (0x00) will USUALLY generate errors in most versions of sed. The latest versions of GNU sed and ssed are an EXCEPTION; they permit nulls in the input files and also in regexes.

On Unix platforms, the 'echo' COMMAND may allow INSERTION of octal or hex values, e.g., `echo "nnn"` or `echo -n "nnn"`. The echo command may also support syntax like '\b' or '\t' for backspace or tab characters. Check the MAN pages to see what syntax your version of echo supports. Some versions support the following:

# replace 0x1A (32 octal) with ASCII letters
sed 's/'`echo "32"`'/Ctrl-Z/g'

# note the 3 backslashes in the command below
sed "s/.`echo \b`//g"

Several versions of sed support the notation xHH, where "HH" are two hex digits, 00-FF: ssed, GNU sed v3.02.80 and above, GNU sed v1.03, sed16 and sed15 (HHsed). Try to use one of those versions.

Sed is not intended to process binary or object code, and files which contain nulls (0x00) will usually generate errors in most versions of sed. The latest versions of GNU sed and ssed are an exception; they permit nulls in the input files and also in regexes.

On Unix platforms, the 'echo' command may allow insertion of octal or hex values, e.g., `echo "nnn"` or `echo -n "nnn"`. The echo command may also support syntax like '\b' or '\t' for backspace or tab characters. Check the man pages to see what syntax your version of echo supports. Some versions support the following:

# replace 0x1A (32 octal) with ASCII letters
sed 's/'`echo "32"`'/Ctrl-Z/g'

# note the 3 backslashes in the command below
sed "s/.`echo \b`//g"

Several versions of sed permit 'n' to be typed directly into the RHS, which is then converted to a newline on output: ssed, gsed302a+, gsed103 (with the -X switch), sed15+, sedmod, and UnixDOS sed. The easiest solution is to use one of these versions.

For other versions of sed, try one of the following:

(a) If typing the sed script from a Bourne shell, use one backslash "" if the script uses 'single quotes' or two backslashes "" if the script requires "double quotes". In the example below, note that the leading '>' on the 2nd line is generated by the shell to prompt the user for more input. The user types in SLASH, single-quote, and then ENTER to terminate the command:

[sh-prompt]$ echo twolines | sed 's/two/& new
>/'
two new
lines
[bash-prompt]$

(b) Use a script file with one backslash '' in the script, immediately followed by a newline. This will embed a newline into the "replace" portion. Example:

sed -f newline.sed files
 
# newline.sed
s/twolines/two new
lines/g

Some versions of sed may not need the trailing backslash. If so, remove it.

(c) Insert an unused character and PIPE the output through tr:

echo twolines | sed 's/two/& new=/' | tr "=" "n" # produces
two new
lines

(d) Use the "G" command:

G appends a newline, plus the contents of the hold space to the end of the pattern space. If the hold space is empty, a newline is APPENDED anyway. The newline is stored in the pattern space as "n" where it can be addressed by grouping "(...)" and moved in the RHS. Thus, to change the "twolines" example used earlier, the following script will work:

sed '/twolines/{G;s/(two)(lines)(n)/132/;}'

(e) Inserting full lines, not breaking lines up:

If one is not changing lines but only inserting complete lines before or after a pattern, the procedure is much easier. Use the "i" (insert) or "a" (append) command, making the alterations by an external script. To insert "This line is new" BEFORE each line matching a regex:

/RE/i This line is new # HHsed, sedmod, gsed 3.02a
/RE/{x;s/$/This line is new/;G;} # other seds

The two examples above are intended as "one-line" commands entered from the console. If using a sed script, "i" immediately followed by a literal newline will work on all versions of sed. Furthermore, the command "s/$/This line is new/" will only work if the hold space is already empty (which it is by default).

To append "This line is new" AFTER each line matching a regex:

/RE/a This line is new # HHsed, sedmod, gsed 3.02a
/RE/{G;s/$/This line is new/;} # other seds

To append 2 blank lines after each line matching a regex:

/RE/{G;G;} # assumes the hold space is empty

To replace each line matching a regex with 5 blank lines:

/RE/{s/.*//;G;G;G;G;}# assumes the hold space is empty

(f) Use the "y///" command if possible:

On some Unix versions of sed (not GNU sed!), though the s/// command won't accept 'n' in the RHS, the y/// command does. If your Unix sed SUPPORTS it, a newline after "aaa" can be inserted this way (which is not portable to GNU sed or other seds):

s/aaa/&~/; y/~/n/; #assuming no other '~' is on the line!

Several versions of sed permit 'n' to be typed directly into the RHS, which is then converted to a newline on output: ssed, gsed302a+, gsed103 (with the -x switch), sed15+, sedmod, and UnixDOS sed. The easiest solution is to use one of these versions.

For other versions of sed, try one of the following:

(a) If typing the sed script from a Bourne shell, use one backslash "" if the script uses 'single quotes' or two backslashes "" if the script requires "double quotes". In the example below, note that the leading '>' on the 2nd line is generated by the shell to prompt the user for more input. The user types in slash, single-quote, and then ENTER to terminate the command:

[sh-prompt]$ echo twolines | sed 's/two/& new
>/'
two new
lines
[bash-prompt]$

(b) Use a script file with one backslash '' in the script, immediately followed by a newline. This will embed a newline into the "replace" portion. Example:

sed -f newline.sed files
 
# newline.sed
s/twolines/two new
lines/g

Some versions of sed may not need the trailing backslash. If so, remove it.

(c) Insert an unused character and pipe the output through tr:

echo twolines | sed 's/two/& new=/' | tr "=" "n" # produces
two new
lines

(d) Use the "G" command:

G appends a newline, plus the contents of the hold space to the end of the pattern space. If the hold space is empty, a newline is appended anyway. The newline is stored in the pattern space as "n" where it can be addressed by grouping "(...)" and moved in the RHS. Thus, to change the "twolines" example used earlier, the following script will work:

sed '/twolines/{G;s/(two)(lines)(n)/132/;}'

(e) Inserting full lines, not breaking lines up:

If one is not changing lines but only inserting complete lines before or after a pattern, the procedure is much easier. Use the "i" (insert) or "a" (append) command, making the alterations by an external script. To insert "This line is new" BEFORE each line matching a regex:

/RE/i This line is new # HHsed, sedmod, gsed 3.02a
/RE/{x;s/$/This line is new/;G;} # other seds

The two examples above are intended as "one-line" commands entered from the console. If using a sed script, "i" immediately followed by a literal newline will work on all versions of sed. Furthermore, the command "s/$/This line is new/" will only work if the hold space is already empty (which it is by default).

To append "This line is new" AFTER each line matching a regex:

/RE/a This line is new # HHsed, sedmod, gsed 3.02a
/RE/{G;s/$/This line is new/;} # other seds

To append 2 blank lines after each line matching a regex:

/RE/{G;G;} # assumes the hold space is empty

To replace each line matching a regex with 5 blank lines:

/RE/{s/.*//;G;G;G;G;}# assumes the hold space is empty

(f) Use the "y///" command if possible:

On some Unix versions of sed (not GNU sed!), though the s/// command won't accept 'n' in the RHS, the y/// command does. If your Unix sed supports it, a newline after "aaa" can be inserted this way (which is not portable to GNU sed or other seds):

s/aaa/&~/; y/~/n/; #assuming no other '~' is on the line!

Note: "Free" does not mean "public domain" nor does it necessarily mean you will never be charged for it. All VERSIONS of sed in this section except the CP/M versions are based on the GNU general public license and are "free software" by that standard. This means you can get the SOURCE code and develop it further.

At the URLs listed in this category, sed binaries or source code can be downloaded and used WITHOUT FEES or license payments.

Note: "Free" does not mean "public domain" nor does it necessarily mean you will never be charged for it. All versions of sed in this section except the CP/M versions are based on the GNU general public license and are "free software" by that standard. This means you can get the source code and develop it further.

At the URLs listed in this category, sed binaries or source code can be downloaded and used without fees or license payments.

"sed" stands for Stream EDitor. Sed is a non-interactive editor, written by the late Lee E. McMahon in 1973 or 1974. 

Instead of altering a file interactively by moving the cursor on the screen (as with a word processor), the user sends a script of editing instructions to sed, plus the name of the file to edit (or the TEXT to be edited may come as output from a pipe). In this sense, sed works like a filter -- deleting, inserting and changing characters, WORDS, and lines of text. Its range of activity goes from small, SIMPLE changes to very complex ones.

Sed reads its input from stdin (Unix shorthand for "standard input," i.e., the console) or from files (or both), and sends the results to stdout ("standard output," normally the console or screen). Most people use sed first for its substitution features. Sed is often used as a find-and-replace tool.

sed 's/Glenn/Harold/g' oldfile >newfile

will replace every occurrence of "Glenn" with the word "Harold", wherever it OCCURS in the file. The "find" portion is a regular expression ("RE"), which can be a simple word or may contain special characters to allow greater flexibility (for example, to prevent "Glenn" from also matching "Glennon").

My very first use of sed was to add 8 spaces to the left side of a file, so when I printed it, the printing wouldn't begin at the absolute left edge of a piece of paper.

sed 's/^/ /' myfile >newfile # my first sed script
sed 's/^/ /' myfile | lp # my next sed script

Then I learned that sed could DISPLAY only one paragraph of a file, beginning at the phrase "and where it came" and ending at the phrase "for all people". My script looked like this:

sed -n '/and where it came/,/for all people/p' myfile

Sed's normal behavior is to print (i.e., display or show on screen) the entire file, including the parts that haven't been altered, unless you use the -n switch. The "-n" stands for "no output". This switch is almost always used in conjunction with a 'p' command somewhere, which says to print only the sections of the file that have been specified. The -n switch with the 'p' command allow for parts of a file to be printed (i.e., sent to the console).

Next, I found that sed could show me only (say) lines 12-18 of a file and not show me the rest. This was very handy when I needed to review only part of a long file and I didn't want to alter it.

# the 'p' stands for print

sed -n 12,18p myfile

Likewise, sed could show me everything else BUT those particular lines, without physically changing the file on the disk:

# the 'd' stands for delete
sed 12,18d myfile

Sed could also double-space my single-spaced file when it came time to print it:

sed G myfile >newfile

If you have many editing commands (for deleting, adding, substituting, etc.) which might take up several lines, those commands can be put into a separate file and all of the commands in the file applied to file being edited:

# 'script.sed' is the file of commands
# 'myfile' is the file being changed
sed -f script.sed myfile # 'script.sed' is the file of commands

"sed" stands for Stream EDitor. Sed is a non-interactive editor, written by the late Lee E. McMahon in 1973 or 1974. 

Instead of altering a file interactively by moving the cursor on the screen (as with a word processor), the user sends a script of editing instructions to sed, plus the name of the file to edit (or the text to be edited may come as output from a pipe). In this sense, sed works like a filter -- deleting, inserting and changing characters, words, and lines of text. Its range of activity goes from small, simple changes to very complex ones.

Sed reads its input from stdin (Unix shorthand for "standard input," i.e., the console) or from files (or both), and sends the results to stdout ("standard output," normally the console or screen). Most people use sed first for its substitution features. Sed is often used as a find-and-replace tool.

sed 's/Glenn/Harold/g' oldfile >newfile

will replace every occurrence of "Glenn" with the word "Harold", wherever it occurs in the file. The "find" portion is a regular expression ("RE"), which can be a simple word or may contain special characters to allow greater flexibility (for example, to prevent "Glenn" from also matching "Glennon").

My very first use of sed was to add 8 spaces to the left side of a file, so when I printed it, the printing wouldn't begin at the absolute left edge of a piece of paper.

sed 's/^/ /' myfile >newfile # my first sed script
sed 's/^/ /' myfile | lp # my next sed script

Then I learned that sed could display only one paragraph of a file, beginning at the phrase "and where it came" and ending at the phrase "for all people". My script looked like this:

sed -n '/and where it came/,/for all people/p' myfile

Sed's normal behavior is to print (i.e., display or show on screen) the entire file, including the parts that haven't been altered, unless you use the -n switch. The "-n" stands for "no output". This switch is almost always used in conjunction with a 'p' command somewhere, which says to print only the sections of the file that have been specified. The -n switch with the 'p' command allow for parts of a file to be printed (i.e., sent to the console).

Next, I found that sed could show me only (say) lines 12-18 of a file and not show me the rest. This was very handy when I needed to review only part of a long file and I didn't want to alter it.

# the 'p' stands for print

sed -n 12,18p myfile

Likewise, sed could show me everything else BUT those particular lines, without physically changing the file on the disk:

# the 'd' stands for delete
sed 12,18d myfile

Sed could also double-space my single-spaced file when it came time to print it:

sed G myfile >newfile

If you have many editing commands (for deleting, adding, substituting, etc.) which might take up several lines, those commands can be put into a separate file and all of the commands in the file applied to file being edited:

# 'script.sed' is the file of commands
# 'myfile' is the file being changed
sed -f script.sed myfile # 'script.sed' is the file of commands

<P>SED -N '/run/!p' &LT; FILENAME 

sed -n '/run/!p' < filename 

<P>SED '/^$/ p' &LT; FILENAME

sed '/^$/ p' < filename

<P>SED 'p' &LT; FILENAME

sed 'p' < filename

SED '1,10 d' &LT; FILENAME

sed '1,10 d' < filename

SED '100,$ s/lite/light/' &LT; FILENAME

sed '100,$ s/lite/light/' < filename

SED '1,00 s/gum/drum/' &LT; FILENAME

sed '1,00 s/gum/drum/' < filename

SED ',^@, s/[0-9][0-9]*//' &LT; FILENAME

sed ',^@, s/[0-9][0-9]*//' < filename

SED '5 s/[0-9][0-9]*//' &LT; FILENAME

sed '5 s/[0-9][0-9]*//' < filename

SED 's/jhon//2g' &LT; FILENAME

sed 's/jhon//2g' < filename

SED 's/bat/ball/2' &LT; FILENAME

sed 's/bat/ball/2' < filename

sed 's/(apple) (MANGO)/2 1/' &LT; filename

sed 's/(apple) (mango)/2 1/' < filename

SED s/apple/(&AMP;)/ &LT; FILENAME

sed s/apple/(&)/ < filename

SED 's///,/' &LT; FILENAME
sed 's|/|,|' < filename

sed 's///,/' < filename
sed 's|/|,|' < filename

SED s/bad/good/g &LT; FILENAME

sed s/bad/good/g < filename

SED s/bad/good/ &LT; FILENAME

sed s/bad/good/ < filename