How can I use quantifiers in a sed substitution expression?

Question

I'm using | sed to indent the result of some command (let's take a plain $ echo something for this example). I want to prefix the result with, say, 10 spaces. The following works fine:

$ echo something | sed 's/^/         /'
         something

But isn't there a way to use quantifiers in the | sed expression?

I tried for example

$ echo something | sed 's/^/ {10}/'
 {10}something

But obviously it doesn't work. {10} isn't interpreted as a quantifier.

And protecting the braces with backslashes doesn't work either:

$ echo something | sed 's/^/ \{10\}/'
 {10}something

Is there a way to use quantifiers in the substitution expression?

Answer 1

I don't think it's possible since the replacement in sed substitutions isn't a regular expression.

An alternative could be to create a variable and use it as replacement, like this:

# use printf to set as many spaces as you want
$ i=$(printf "%10s")

# use the created variable as replacement of the substitution
$ echo something | sed "s/^/$i/"
          something

Answer 2

A lot of good solutions, I especially like @nezabudka's | pr -T -o10 solution, really short and simple.

Now, for the fun of it, I found a "sed only" solution (no printf, no expand, no nothing) :

$ echo something | sed ':L; /^ \{10\}/! {s/^/ /;b L}'
          something

EDIT: At @Barmar's request, some explanation :

• :L; creates a label, named L (you could name it anything)
• We append a space at the beginning of the line, with s/^/ /. Then we go back to the label (b L, we branch to the label L, kind of a goto)
• And we make this expression conditional : it's only executed as long as the line doesn't start with 10 spaces (/^ \{10\}/!)

So, basically, we repeat "add a space at the beginning of the line" until the line begins with 10 spaces

While @nezabudka's pr solution is clearly the easiest way to append spaces in front of a line, this sed solution is more versatile. To add for example 5 times XYZ- in front of a line :

$ echo something | sed ':L; /^\(XYZ-\)\{5\}/! {s/^/XYZ-/;b L}'
XYZ-XYZ-XYZ-XYZ-XYZ-something

Answer 3

Some of Perl's best stuff was stolen from sed, so the similarities can be useful. In this case, the perl solution is simpler and perhaps thinking of it in this way may make the sed solution obvious. What you want is to print 10 spaces and then print your output, rather than transforming the line and printing the result.

echo something | perl -pe 'print " " x 10'

The -p flag adds an implicit print $_ to the end of the command.

If you really want to use a regex, use the /e flag

echo something | perl -pe 's/^/" " x 10/e'

which runs the substitution as an executable statement and uses the result as the subbed value. (in this case I get 10 's by using the repetition operator, x )

Answer 4

Perhaps the pr utility will suit you for this purpose:

echo $'something\nstuff' | pr -T -o10
          something
          stuff

Don't forget about the -T option. That stops pr from paginating input and writing headers.

Answer 5

You could get your shell to generate the sequence of 10 spaces.

For instance, with zsh:

$ echo something | sed "s/^/${(l[10])}/"
          something

Here using the left padding parameter expansion flag applied to the empty parameter expansion. You could just as well use the right one here. To pad with a different character:

$ echo something | sed "s/^/${(l[10][.])}/"
..........something

Or even sequence of characters:

$ echo something | sed "s/^/${(l[10][<>])}/"
<><><><><>something

Answer 6

Using Raku (formerly known as Perl_6)

raku -pe 's/ ^^ (.*) $$ /{print " " x (10-$0.chars); $0}/;'

Sample Input:

when
in
the
course
of
human
events

Sample Output:

  when
    in
   the
course
    of
 human
events

Nice coding in Perl from @Boyd led me to this answer, which is a simple way to right-justify lines. The Raku s/// operator tolerates extraneous spaces on the left (matcher) side, so I've broken out the match elements: ^^, .*, and $$. Of course, the simpler answer to the question is to delete the -$0.chars section of the code, so everything is indented 10 spaces (after @Boyd):

echo something | raku -pe 'print " " x 10;'

For the code presented at the top, clearly you can change the matcher, and it would be fun to specifically match (before? after?) lines starting with proofreader-marks, such as § or ¶. Finally, Raku is advertised to be Unicode-ready, so there shouldn't be a worry about mis-alignment (although the test below is extremely limited):

raku -pe 's/ ^^ (.*) $$ /{print " " x (4-$0.chars); $0}/;' uni-test.txt
   A
   Á
   Å
   À
   Ä
   B
   ß
   œ
   þ

https://www.raku.org/

Answer 7

Another (gnu) sed exclusive solution below: It is possible using the sed GNU extension "e" command thats allows one to pipe a shell command input directly from sed as this example.

Note that the {1..10} expression: I think it is bash extension not sure it will works with other shells.

echo -e "foo\nbar\r" | sed 'e for i in {1..10};do echo -n ".";done'
..........foo 
..........bar