Get rid of whitespace on otherwise empty lines

Question

Ah, yet another of my selfish uses of this Stack.

Being a Chromebook owner, I'm a frequent user of the Ace IDE, the editor used by Cloud9. It has lots of tools for dealing with excess whitespace, but it notably lacks one: clearing empty lines.

Your mission today is, given an input from a place I can copy-paste to [;)], output something identical, save all spaces and tabulators on otherwise empty lines.

I'll give some examples, with #s representing whitespace characters to be removed.

---

INPUT 1:

if (this.Color !== 'blue') {
##
  this.Color = 'blue';
}

OUTPUT:

if (this.Color !== 'blue') {
[empty line]
  this.Color = 'blue';
}

---

INPUT 2:

function outputSomething(times) {
  for (var iter = 0; iter < times; iter++) {
    console.log('"# # " represents a tabulator');
    // This is a comment
# # 
}}

OUTPUT:

function outputSomething(times) {
  for (var iter = 0; iter < times; iter++) {
    console.log('"# # " represents a tabulator');
    // This is a comment
[empty line]
}}

---

INPUT 3:

var x = 'Do you prefer spaces or tabs?';
var y = 'I\'m using both here. Sue me.';
# # ####
console.log(x + ' ' + y);

OUTPUT:

var x = 'Do you prefer spaces or tabs?';
var y = 'I\'m using both here. Sue me.';
[empty line]
console.log(x + ' ' + y);

---

You may process the input however you like. Output wherever, so long as I can copy-paste from it [;)].

Standard loopholes apply, shortest answer in bytes wins!

Answer 1

Retina, 5 bytes

%G`\S

Try it online!

A not so obvious approach rewards us with a better score :)

Explanation

G indicates this as a Grep stage, keeping only those lines where a match to the regex given (\S, matches non-space characters) can be found. If it wasn't for the starting % this would completely remove lines instead of just "emptying" them.

The % is a modifier which applies the stage once to each line and then joins the results with newlines: in our case this means that the empty string returned by Grep for whitespace-only lines will become an empty line in the result.

Answer 2

sed, 6 bytes

/\S/!g

Try it online!

/  /!  # If the line doesn't contain...
 \S    # anything non-whitespace (i.e. the entire line is whitespace)
     g #   replace the pattern space with the hold space which is empty

Answer 3

Japt, 10 8 6 5 4 bytes

mx1R

Try it online!

Explanation

(from the Japt docs)
.m(f,s=""):
Splits this with s, maps each item by f, then rejoins with s.

So mx1R splits the string by R which is a newline, trims the right hand side of each line using x1 and joins the strings again with a newline.

Saved 2 bytes thanks to ETHproductions.

Answer 4

V, 5, 4 bytes

ÇÓ/D

Try it online!

Explanation:

Ç       " On every line not matching the following regex:
 Ó/     "   a non-whitespace character...
   D    "   Delete the whole line

Hexdump:

00000000: c7d3 2f44                                ../D

Answer 5

JavaScript (ES6), 26 bytes

I don't understand why this is getting so many upvotes!

s=>s.replace(/^\s+$/gm,``)

---

Try It

f=
s=>s.replace(/^\s+$/gm,``)
i.addEventListener("input",_=>o.innerText=f(i.value))

<textarea id=i></textarea><pre id=o>

Answer 6

Python 3, 63 55 36 bytes

lambda s:[x.strip()and x for x in s]

Input and output are arrays of strings. Join on '\n'.

For the original program that I/O's strings:

lambda s:'\n'.join(x.strip()and x for x in s.split('\n'))

Try it online!

Saved 8 bytes thanks to @Rod!
Saved 19 bytes thanks to @LeakyNun!

Answer 7

CJam, 18 16 bytes

qN/{_" 	"-\e&N}%

Note that the string contains 1 space and 1 tab.

Try it online!

Explanation

q                 e# Read the input
 N/               e# Split it on newlines
   {              e# Apply this block to each line:
    _             e#  Copy the line
     "  "-        e#  Remove all spaces and tabs from the copy
          \       e#  Bring the original to the top of the stack
           e&     e#  Logical AND; returns the original line if the copy is truthy 
                  e#    (non-empty), otherwise returns the copy line
             N    e#  Push a newline after the line
              }%  e# (end of block)

Answer 8

Retina, 8 bytes

m`^\s+$

A really pointless challenge. m makes it multiline (ignores newline). \s matches both space and tab.

Try it online!

Answer 9

Vim, 20 18 16 13 10 bytes

I am by no means a Vim expert, but this question needs a Vim answer.

:%s/^\s*$<cr>

<cr> is a carriage return.

Changelog:

• :norm instead of :normal (-2 bytes)
• Switching to * instead of + means we will match already empty lines, but that doesn't matter. And now we can get rid of \v (very magic option) (-2 bytes)
• New approach: Instead of replacing every line that matches with an empty line, we replace every line that doesn't have a no non-whitespace characters with an empty line. (-3 bytes)
• Actually, a normal replacement is shorter (thanks, @DJMcMayhem) (-3 bytes)

Answer 10

AWK, 12 11 bytes

!NF{$0=""}1

Try it online!

I was just feeling like AWK should have an answer too

It works by:

1. Checking if there are no fields in the input. AWK by default uses all whitespace as separator between fields
2. If there are no fields, change the input line to an empty string
3. Print the line. As 1 is a truthy value, it runs the default command which is printing the line

Answer 11

APL (Dyalog), 11 10 bytes

'\s+$'⎕R''

⎕R is an operator which derives a function which replaces stuff. In this case, anything matched by the RegEx is replaced with an empty string.

Answer 12

Ruby, 22 bytes

->s{s.gsub /^\s+$/,''}

Straightforward regex solution

Answer 13

Java 7, 57 bytes

String c(String s){return s.replaceAll("(?m)^\\s+$","");}

Explanation:

String c(String s){     // Method with String parameter and String return-type
  return s.replaceAll(  //  Return the input String after we've replaced
    "(?m)^\\s+$",       //  all lines only containing whitespaces
    "");                //  with empty Strings
                        //    (NOTE: `(?m)` enables multiline regex)
}                       // End of method

Test code:

Try it here.

class M{
  static String c(String s){return s.replaceAll("(?m)^\\s+$","");}
  
  public static void main(String[]a){
    System.out.println(c("if (this.Color !== 'blue') {\n \t\n  this.Color = 'blue';\n}"));
    System.out.println();
    System.out.println(c("function outputSomething(times) {\n  for (var iter = 0; iter < times; iter++) {\n    console.log('\"# # \" represents a tabulator');\n    // This is a comment\n  \t\n}}"));
    System.out.println();
    System.out.println(c("var x = 'Do you prefer spaces or tabs?';\nvar y = 'I\'m using both here. Sue me.';\n    \t\t\t \nconsole.log(x + ' ' + y);"));
  }
}

Answer 14

Groovy, 31 bytes

{it.replaceAll(/\n\s+\n/,"\n")}

Answer 15

Perl 6,  15  12 bytes

15

{S:g/^^\h+$$//}

Try it

{         # bare block lambda with implicit parameter ｢$_｣

  S       # string replace (implicitly against ｢$_｣)
  :global # globally
  /
    ^^    # match beginning of line
      \h+ # match at least one horizontal whitespace
    $$    # match end of line

  //      # replace with nothing
}

---

11+1

perl6 -pe 's/^^\h+$$//'

Largely the same as above.

• -p runs the code for every line of input, putting the line into $_ and printing whatever is left in $_.
• s replaces in-place, whereas S returns the result.
• No need for :g/:global as -p takes care of that.

Answer 16

Python 2, 26 bytes

lambda l:map(str.rstrip,l)

Try it online! Inputs and outputs a list of strings.

This takes advantage of the ruling in the comments that trailing whitespace may be removed on non-empty lines.

Answer 17

C, 168 bytes

#define P putchar(*t++)
s;e(char*t){s=0;while(*t>10)if(*t!=32|*t!=9)return 0;else t++,s++;return s;}
r(char*t){while(*t==10)P;if(!*t)return;if(!e(t))while(*t)P;t+=e(t);}

Detailed

#include <stdio.h>

int e (char * t)
{
    int s = 0;

    // till the end of the line
    while (*t!='\0' && *t!='\n')
        // if it's not a space
        if (*t!=' ' || *t!='    ')
            // ignore the line
            return 0;
        else
            // count the space
            t++, s++;

    // return number of spaces
    return s;
}

void r (char * t)
{
    // skip to empty lines
    while (*t != '\0' && *t == '\n') putchar('\n'), t++;

    // stop at end of string
    if (*t == '\0') return;

    // if there is contnet print it
    if (!e(t)) while(*t != '\0') putchar(*t), t++;

    // skip to the end of line
    t += e(t);
}

int main (int argc, char**argv)
{
    if (argc > 1) r(argv[1]);
    putchar('\n');
    return 0;
}

Answer 18

C, 100 bytes

c,i,j;f(char*s){for(i=j=c=0;s[i];s[++j]^10?c=s[j]^32:(printf(!c?"\n":"%.*s",j-i+1,s+i),c=0,i=j+1));}

See it work online.

Answer 19

Vim, 13 9 bytes

:v/\S/le↵

Edits:

• Original answer: :v/\S/d↵ (based on this vim question on SO).
  It deletes empty lines, which isn't the expected behavior.

• Valid answer using vglobal: :v/\S/norm D↵

• Now using the left-align ex command instead of normal D

Answer 20

QuadR, 5 bytes

\s+$

Try it online!

\s+ replace one or more whitespace chars followed by
$ end of line

 with nothing