Strip comments from a string: Difference between revisions

{{clarify task}}

 

The task is to remove text that follow any of a set of comment markers, (in these examples either a hash or a semicolon) from a string or input line.

 

 

<br><br>

 

=={{header|Ada}}==

procedure Program is

Comment_Characters : String := "#;";

end;

end loop;

 

=={{header|Aime}}==

{

b.size(b.look(0, ";#")).bf_drop(" \t").bb_drop(" \t");

 

0;

 

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny].}}

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d]}}

 

PROC trim comment = (STRING line, CHAR marker)STRING:(

grep in string(re marker, line, index, NIL);

print((q, line[:index-1], q, new line))

Output:

<pre>

=={{header|ALGOL W}}==

Leading and trailing spaces are removed from the result, as per the March 29 2011 task version.

% determines the non-comment portion of the string s, startPos and endPos are %

% returned set to the beginning and ending character positions (indexed from 0) %

testStripComments( " apples, pears" )

end

{{out}}

<pre>

 

=={{header|Applesoft BASIC}}==

20 S$(1)="APPLES, PEARS # AND BANANAS"

30 S$(2)="APPLES, PEARS ; AND BANANAS"

250 IF A$ = " " THEN NEXT I

260 LET S$ = MID$(S$, 1, I)

 

=={{header|AutoHotkey}}==

str := "apples, pears # and bananas"

str2:= "apples, pears, `; and bananas" ; needed to escape the ; since that is AHK's comment marker

}

return String1

Output:

<pre>

apples, pears,

</pre>

 

=={{header|AutoIt}}==

It was always said in discussion, the task is not really stripping comments. It's only a truncation.

Dim $Line1 = "apples, pears # and bananas"

Dim $Line2 = "apples, pears ; and bananas"

Next

EndFunc ;==>_StripAtMarker

Output:

<pre>

That means: the comment starts with the first semicolon outside a string.

 

Dim $aLines[4] = _

[ _

Next

EndFunc ;==>_LineStripComment

Output:

<pre>

=={{header|AWK}}==

 

{

sub("[ \t]*[#;].*$","",$0);

print;

 

 

=={{header|Bracmat}}==

oranges, mangos ; and a durian"

: ?text

& !newText \n cleanUp$!text:?newText

& out$(str$!newText)

Output:

<pre>

 

=={{header|C}}==

 

int main()

return 0;

Output:

<pre>

The modified string is : apples, pears

Do you want to repeat (y/n): n

</pre>

 

=={{header|C++}}==

#include <string>

 

}

return 0;

Sample output:

<pre>

</pre>

 

 

 

 

 

=={{header|Common Lisp}}==

"Truncate s at the first occurrence of a character in cs."

(defun comment-char-p (c)

(some #'(lambda (x) (char= x c)) cs))

(let ((pos (position-if #'comment-char-p s)))

 

{{Out}}

 

=={{header|D}}==

 

string remove1LineComment(in string s, in string pat=";#") {

 

writeln(s, "\n====>\n", s.remove1LineComment());

{{out}}

<pre>apples, pears # and bananas

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

Writeln('apples, pears ; and bananas --> ' + DoStripComments('apples, pears ; and bananas',';'));

Readln;

 

=={{header|DWScript}}==

begin

var p := FindDelimiter('#;', s);

 

PrintLn(StripComments('apples, pears # and bananas'));

 

=={{header|Erlang}}==

-module( strip_comments_from_string ).

 

not_comment( $; ) -> false;

not_comment( _ ) -> true.

{{out}}

<pre>

 

=={{header|F_Sharp|F#}}==

s

|> Seq.takeWhile (fun c -> c <> '#' && c <> ';')

|> Seq.map System.Char.ToString

 

=={{header|Factor}}==

: strip-comments ( str -- str' )

 

=={{header|Fantom}}==

Using a regular expression:

{

static Str removeComment (Str str)

echo (removeComment ("String with comment ; here"))

}

 

=={{header|Forth}}==

 

Tested with GForth on Windows

 

: LASTCHAR ( addr len -- addr len c) 2DUP + C@ ;

 

: COMMENT-STRIP ( addr len -- addr 'len) -LEADING -COMMENT -TRAILING ;

<pre>S" apples, pears # and bananas" COMMENT-STRIP TYPE apples, pears ok

S" apples, pears ; and bananas" COMMENT-STRIP TYPE apples, pears ok</pre>

 

=={{header|Fortran}}==

module string_routines

!****************************************************

!****************************************************

end program main

output:

<pre>

 

=={{header|FreeBASIC}}==

 

Sub stripComment(s As String, commentMarkers As String)

Print

Print "Press any key to quit"

 

{{out}}

=> Length = 0

</pre>

 

=={{header|Go}}==

 

import (

fmt.Printf("stripped: %q\n", stripComment(s))

}

Output:

<pre>

 

=={{header|Groovy}}==

Testing:

 

=={{header|Haskell}}==

 

main = getContents >>=

 

=={{header|Icon}} and {{header|Unicon}}==

# return part of string up to first character in 'markers',

# or else the whole string if no comment marker is present

write (strip_comments ("apples, pears # and bananas", cset ("#;")))

write (strip_comments ("apples, pears ; and bananas", cset ("#;")))

 

Output:

 

=={{header|Inform 7}}==

 

When play begins:

say "[T] -> ";

replace the regular expression "<#;>.*$" in T with "";

 

Since square brackets have a special meaning in strings, Inform's regular expression syntax uses angle brackets for character grouping.

 

=={{header|J}}==

 

"apples, pears"

strip ' apples, pears ; and bananas'

 

=={{header|Java}}==

 

public class StripLineComments{

}

}

 

=={{header|JavaScript}}==

===ES5===

var re1 = /^\s+|\s+$/g; // Strip leading and trailing spaces

var re2 = /\s*[#;].+$/g; // Strip everything after # or ; to the end of the line, including preceding spaces

 

alert(stripComments(s1) + '\n' + stripComments(s2));

 

A more efficient version that caches the regular expressions in a closure:

 

var re1 = /^\s+|\s+$/g;

var re2 = /\s*[#;].+$/g;

};

}());

A difference with the two versions is that in the first, all declarations are processed before code is executed so the function declaration can be after the code that calls it. However in the second example, the expression creating the function must be executed before the function is available, so it must be before the code that calls it.

 

===ES6===

'use strict';

 

// MAIN ---

return main();

{{Out}}

<pre>apples, pears

=={{header|jq}}==

If your version of jq has regex support, the task can be accomplished with the following one-liner:

 

Otherwise, we can define strip_comment as a jq filter, as follows. For clarity, the helper functions are presented as top-level functions.

 

def is_whitespace: . as $in | " \n\r\f\t" | index($in);

 

end ) as $ix

| if $ix then .[0:$ix] else . end

 

'''Example''':

{{out}}

 

 

=={{header|Julia}}==

<tt>striplinecomment</tt> is designed to be flexible and robust. By default <tt>#</tt> and <tt>;</tt> are considered comment defining characters, but any characters can be used by passing them as the string <tt>cchars</tt>. All such characters are escaped in the regular expression used to eliminate comments to allow characters special to the Regex language (e.g. <tt>^</tt>, <tt>$</tt>, <tt>[</tt>) to be used as a comment character.

b = strip(a)

0 < length(cchars) || return b

for c in cchars

r = Regex(@sprintf "\\%c.*" c)

end

strip(b)

end

 

"apples, pears ; and bananas",

" apples, pears & bananas ",

 

for t in tests

println(" \"", s, "\"")

end

 

{{out}}

 

It then removes whitespace from the beginning and end of the resulting string:

 

val r = Regex("""(/\*.*\*/|//.*$)""")

)

for (string in strings) println(stripComments(string))

 

{{out}}

 

=={{header|Liberty BASIC}}==

string2$ = "pears;, " + chr$(34) + "apples ; " + chr$(34) + " an;d bananas"

commentMarker$ = "; #"

next i

parse$ = Left$(string$, (i - 1))

 

=={{header|Lua}}==

 

s1 = "apples, pears # and bananas"

 

print ( string.match( s1, "[^"..comment_symbols.."]+" ) )

 

=={{header|Maple}}==

 

apples, pears ; and bananas";

b = StringReplace[a, RegularExpression["[ ]+[#;].+[\n]"] -> "\n"];

<pre>"apples, pears\napples, pears"</pre>

 

=={{header|MATLAB}} / {{header|Octave}}==

e = min([find(line=='#',1),find(line==';',1)]);

if ~isempty(e)

end;

end;

Output:

<pre>>> stripcomment('apples, pears # and bananas\n')

 

=={{header|MiniScript}}==

comment = test.indexOf("#")

if comment == null then comment = test.indexOf(";")

print strip("This is a semicolon test ; a comment") + "."

print strip("This is a no comment test ") + "."

{{out}}

<pre>

 

=={{header|Nim}}==

line.split(sep)[0].strip(leading = false)

 

 

=={{header|Objeck}}==

 

class StripComments {

};

}

 

=={{header|OCaml}}==

let len = String.length str in

let rec aux print i =

strip_comments "apples, pears # and bananas\n";

strip_comments "apples, pears ; and bananas\n";

 

or with an imperative style:

 

let print = ref true in

String.iter (function

| ';' | '#' -> print := false

| '\n' -> print_char '\n'; print := true

 

=={{header|Oforth}}==

 

| firstMarker |

markers map(#[ s indexOf ]) reduce(#min) ->firstMarker

 

{{out}}

 

=={{header|Perl}}==

{

s/[#;].*$//s; # remove comment

s/\s+$//; # remove trailing whitespace

print

 

=={{header|Phix}}==

Added a couple of things that can go wrong with something nowhere near sufficiently smart or for that matter language-specific enough.<br>

A line comment inside a block comment (eg " /* left -- right */") could also be very dodgy, and perhaps vice versa.

{{out}}

<pre>

 

=={{header|PicoLisp}}==

Output:

<pre>

 

=={{header|PL/I}}==

if k = 0 then put skip list (text);

 

=={{header|Prolog}}==

{{works with|SWI Prolog}}

This version is implemented as a state automata to strip multiple lines of comments.

stripcomment([A|AL],[A|BL],a) :- \+ A=0';, \+ A=0'# , \+ A=10, \+ A=13 , stripcomment(AL,BL,a).

stripcomment([A|AL], BL ,a) :- ( A=0';; A=0'#), \+ A=10, \+ A=13 , stripcomment(AL,BL,b).

apples, pears # and bananas",

stripcomment(In,Out),

Output:

<pre>

</pre>

This version uses prolog's pattern matching with two append/3 to strip 1 line.

At the query console:

<pre>

 

=={{header|PureBasic}}==

Protected result$=Str$, l, l1, l2

l1 =FindString(Str$,"#",1)

EndIf

ProcedureReturn result$

Implementation

#instring2 ="apples, pears ; and bananas"

 

PrintN(Strip_comments(#instring1))

Output:<pre>

apples, pears

=={{header|Python}}==

===Procedural===

for s in sep:

i = line.find(s)

print remove_comments('apples ; pears # and bananas', ';#')

print remove_comments('apples ; pears # and bananas', '!')

 

===Regular expressions===

You could also use a regular expression

 

m = re.match(r'^([^#]*)#(.*)$', line)

if m: # The line contains a hash / comment

line = m.group(1)

 

===Functional===

which is defined over strings as well as lists.

{{Works with|Python|3.7}}

 

from itertools import takewhile

'''

)

{{Out}}

<pre>apples, pears

apples, pears</pre>

 

=={{header|R}}==

This is most cleanly accomplished using the <code>stringr</code> package.

 

{

if(!require(stringr)) stop("you need to install the stringr package")

str_trim(str_split_fixed(str, "#|;", 2)[, 1])

 

Example usage:

 

"apples, pears # and bananas", # the requested hash test

"apples, pears ; and bananas", # the requested semicolon test

" apples, pears # and bananas" # with preceding spaces

)

 

=={{header|Racket}}==

 

#lang at-exp racket

 

 

(strip-comments2 text) ; -> "apples, pears\napples, pears"

 

=={{header|Red}}==

Red has an embedded parse engine called Parse.

For more info on the Parse dialect. http://www.red-lang.org/2013/11/041-introducing-parse.html.

>> parse s: "apples, pears ; and bananas" [to [any space ";"] remove thru end]

== true

>> s

== "apples, pears"

 

But you can also use simple series operations to find where something occurs, clear from that position, and trim leading and trailing spaces.

s: "apples, pears ; and bananas"

dlms: charset "#;"

trim head clear find s dlms

== "apples, pears"

 

=={{header|REXX}}==

<br>The fourth subroutine is similar to the third version but more idiomatic.

<br><br>All four subroutines trim leading &nbsp; ''and'' &nbsp; trailing blanks after stripping the "comments".

old1= ' apples, pears # and bananas' ; say ' old ───►'old1"◄───"

new1= stripCom1(old1) ; say ' 1st version new ───►'new1"◄───"

if p\==0 then x=left(x,p-1) /*shorten the X string by one character*/

end /*k*/ /* [↑] If p==0, then char wasn't found*/

'''output'''

<pre>

 

===version 2===

Call stripd ' apples, pears and bananas'

Exit

Say '>'old'<'

Say '>'new'<'

 

=={{header|Ring}}==

aList = 'apples, pears # and bananas'

see aList + nl

if nr > 0 cList = substr(bList,1,nr-1) ok

return cList

 

=={{header|Ruby}}==

def strip_comment( markers = ['#',';'] )

re = Regexp.union( markers ) # construct a regular expression which will match any of the markers

p str.strip_comment('and')

p " \t \n ;".strip_comment

{{out}}

<pre>

 

=={{header|Rust}}==

input

.find(markers)

println!("{:?}", strip_comment("apples, pears ; and bananas", &['#', ';']));

println!("{:?}", strip_comment("apples, pears and bananas ", &['#', ';']));

{{out}}

<pre>

 

=={{header|Scala}}==

def stripComments1(s:String, markers:String =";#")=s takeWhile (!markers.contains(_)) trim

print("apples, pears ; and bananas")

}

Output:

<pre>'apples, pears # and bananas' =>

=={{header|Scheme}}==

{{works with|Guile}}

 

(define (strip-comments s)

 

(display (strip-comments "apples, pears # and bananas"))(newline)

Output:<pre>apples, pears

apples, pears</pre>

 

=={{header|sed}}==

# Strip comments

 

=={{header|Seed7}}==

 

const func string: stripComment (in string: line) is func

writeln(stripComment(line));

end for;

 

Output:

 

=={{header|Sidef}}==

(s - %r'[#;].*').strip;

}

" apples, pears "].each { |s|

say strip_comment(s).dump;

{{out}}

<pre>

"apples, pears"

</pre>

 

=={{header|Tcl}}==

# Switch the RE engine into line-respecting mode instead of the default whole-string mode

regsub -all -line "\[$commentChars\].*$" $inputString "" commentStripped

# Now strip the whitespace

regsub -all -line {^[ \t\r]*(.*\S)?[ \t\r]*$} $commentStripped {\1}

Demonstration:

set input "apples, pears # and bananas

apples, pears ; and bananas"

# Do the stripping

Output:

<pre>

</pre>

The above code has one issue though; it's notion of a set of characters is very much that of the RE engine. That's possibly desirable, but to handle ''any'' sequence of characters as a set of separators requires a bit more cleverness.

# Convert the character set into a transformation

foreach c [split $commentChars ""] {lappend map $c "\uFFFF"}; # *very* rare character!

# Now strip the whitespace

regsub -all -line {^[ \t\r]*(.*\S)?[ \t\r]*$} $commentStripped {\1}

Output in the example is the same as above.

 

=={{header|TUSCRIPT}}==

strngcomment=*

DATA apples, pears # and bananas

x=SPLIT (s,comment_char,string,comment)

PRINT string

Output:

<pre>

{{works with|pdksh}}

Adapted from the Advanced Bash-Scripting Guide, section 10.1 [http://tldp.org/LDP/abs/html/string-manipulation.html Manipulating Strings].

bash$ b='apples, pears # and bananas'

bash$ echo ${a%%;*}

bash$ echo ${b%%#*}

apples, pears

 

=={{header|VBScript}}==

Function strip_comments(s,char)

If InStr(1,s,char) > 0 Then

WScript.StdOut.WriteLine strip_comments("apples, pears # and bananas","#")

WScript.StdOut.WriteLine strip_comments("apples, pears ; and bananas",";")

 

=={{header|zkl}}==

if (Void!=(n:=text.find(c))) text=text[0,n];

text.strip() // remove leading and trailing white space

foreach c in (vm.arglist[1,*]){ text=strip(text,c) }

text

Or, if you want the all-in-one stripper:

vm.arglist[1,*].reduce('wrap(text,c){

if (Void!=(n:=text.find(c))) text[0,n] else text

},text)

.strip()

{{out}}

<pre>