869

How can I comment multiple lines in Ruby?

1
  • 9
    It's rather unfortunate that multiline comments in ruby look very much like a block of code. And given the high points awarded to this question (and the accepted answer) the people working on the ruby syntax should clearly think a bit about it.
    – Nick
    Commented Jul 25, 2015 at 19:30

10 Answers 10

1511
#!/usr/bin/env ruby

=begin
Every body mentioned this way
to have multiline comments.

The =begin and =end must be at the beginning of the line or
it will be a syntax error.
=end

puts "Hello world!"

<<-DOC
Also, you could create a docstring.
which...
DOC

puts "Hello world!"

"..is kinda ugly and creates
a String instance, but I know one guy
with a Smalltalk background, who
does this."

puts "Hello world!"

##
# most
# people
# do
# this


__END__

But all forgot there is another option.
Only at the end of a file, of course.
  • This is how it looks (via screenshot) - otherwise it's hard to interpret how the above comments will look. Click to Zoom-in:

Comments in a text-editor

12
  • 31
    I really prefer using # over them all, mostly because it visually separates the commented lines better than =begin/=end or using the here-to method. And, nice job. Commented Dec 3, 2010 at 4:44
  • 39
    It's interesting that this answer makes some flaws in the syntax highlighter obvious.
    – ZoFreX
    Commented Nov 16, 2012 at 19:59
  • 78
    Don't forget that =begin and =end cannot be preceded by any whitespace.
    – bergie3000
    Commented Feb 9, 2013 at 0:02
  • 18
    And It is not possible to use =begin =end within a method Commented Jan 9, 2014 at 15:02
  • 9
    It's important to note that in the above example code, only the first =begin...=end and last block using # are picked up by rdoc when generating documentation. Commented Aug 5, 2014 at 19:50
152
=begin
My 
multiline
comment
here
=end
4
  • 5
    Sure, you could do this. It works. This is incredibly rare. I find it ugly. Maybe I'm stuck in my ways?
    – David J.
    Commented Jun 22, 2012 at 17:22
  • 57
    I've found that if I include a tab before =begin or =end, the comments don't work. The =begin and =end each need to be written at the beginning of each line. Commented Jun 22, 2012 at 20:51
  • 1
    you're not alone @DavidJames. I've personally opted to have them all commented out by my editor. CMD+/ or ALT+/ is the convention for most. Commented Oct 31, 2016 at 23:06
  • 1
    @DavidJames, what would you do instead? Type a # and space before every single line? It's a lot of keystrokes especially if I start adding line breaks. Commented Nov 15, 2016 at 16:34
71

Despite the existence of =begin and =end, the normal and a more correct way to comment is to use #'s on each line. If you read the source of any ruby library, you will see that this is the way multi-line comments are done in almost all cases.

9
  • 5
    You might get arguments about the "more correct" part of your statement as they're both valid. I prefer using # because it's more obvious. When commenting out code it's important to make it obvious that's what happened. If you're viewing the code without the benefit of code coloring in an editor using =begin/=end can make it tough to figure out why code is being ignored. Commented Dec 3, 2010 at 4:48
  • 6
    Sure, there are many "valid" ways to write comments. Let's be practical here. If you actually write Ruby and read what others write, you should be using # comments. (I am mystified why this had two downvotes. I guess the Stack Overflow community has to get it wrong sometimes!)
    – David J.
    Commented Jun 22, 2012 at 17:17
  • 4
    3 == three where def three; 1 + 1 + 1 end. Therefore both are valid. Who cares? Use 3!
    – David J.
    Commented Jun 22, 2012 at 17:19
  • 1
    @theTinMan While true, generally the only time you'd lack syntax highlighting (in my experience) is when you're using vi on a production server. In which case, you probably shouldn't be doing your development there, anyway. Commented Aug 5, 2014 at 19:10
  • 2
    This isn't actually an answer to his question, hence the downvotes.
    – Shayne
    Commented Apr 13, 2016 at 1:23
24
#!/usr/bin/env ruby

=begin
Between =begin and =end, any number
of lines may be written. All of these
lines are ignored by the Ruby interpreter.
=end

puts "Hello world!"
3
  • 1
    +1 because I had no idea nesting was a thing in Ruby multiline comments. Commented Aug 5, 2014 at 19:17
  • 4
    @ParthianShot - It is not a thing - =begin and =end are ignored if not at the beginning of a line. Nesting does not seem to be possible.
    – skagedal
    Commented Feb 24, 2015 at 21:05
  • Nesting a comment inside a comment would result in either a single comment or a syntax error from trying to end a comment where there is no comment to end. /*I am a\n#nested\ncomment, which really serves no purpose*/ /*I am bound /*to*/ FAIL!*/ It could make sense if you have single line comments and code inside of a multiline comment, such as a function with documentation that you don't want people to use, but you also don't want to remove it from the file. Commented Jul 24, 2016 at 21:57
20

Using either:

=begin
This
is
a
comment
block
=end

or

# This
# is
# a
# comment
# block

are the only two currently supported by rdoc, which is a good reason to use only these I think.

1
  • 1
    Another good reason to stick to =begin or # is that both <<-DOC and " syntaxes will generate useless string literals at execution.
    – Cœur
    Commented May 16, 2019 at 12:27
18
=begin
comment line 1
comment line 2
=end

make sure =begin and =end is the first thing on that line (no spaces)

15

Here is an example :

=begin 
print "Give me a number:"
number = gets.chomp.to_f

total = number * 10
puts  "The total value is : #{total}"

=end

Everything you place in between =begin and =end will be treated as a comment regardless of how many lines of code it contains between.

Note: Make sure there is no space between = and begin:

  • Correct: =begin
  • Wrong: = begin
14
=begin
(some code here)
=end

and

# This code
# on multiple lines
# is commented out

are both correct. The advantage of the first type of comment is editability—it's easier to uncomment because fewer characters are deleted. The advantage of the second type of comment is readability—reading the code line by line, it's much easier to tell that a particular line has been commented out. Your call but think about who's coming after you and how easy it is for them to read and maintain.

3
  • IMO, =begin and =end do not visually convey that what is in-between is a comment... Clojure, for example, uses (comment :whatever) which at leads says what it means: stackoverflow.com/questions/1191628/block-comments-in-clojure
    – David J.
    Commented Aug 6, 2014 at 3:36
  • 1
    Neither do "/*" and "*/" in Java, C and C++. As with the Ruby syntax, large blocks of code might be commented out between those two characters, and everyone who knows the basics of the language knows what they mean. Commented Aug 6, 2014 at 14:11
  • 1
    Syntax coloring (in vim, for example) shows that the first type is a comment. In that case, the first type has no disadvantages. Commented Apr 12, 2017 at 20:41
4

In case someone is looking for an alternate way to comment multiple lines, for instance:

<%
=begin
%>
  ... multiple HTML lines to comment out
  <%= image_tag("image.jpg") %>
<%
=end
%>

can be replaced with:

<% if false # The following section is commented out because... %>
  ... multiple HTML lines to comment out
  <%= image_tag("image.jpg") %>
<% end # if false %>

This is not strictly commenting, because there is an if sentence, and therefore there is a very small use of the CPU, so I wouldn't use this kind of resource inside code that runs frequently.

However sometimes I find it more appealing.

Does anyone know if there is a difference in main memory usage with this practice?

2
  • 1
    The multi line comment with begin and end, like your first code snippet, actually works.
    – Robert
    Commented Sep 28, 2020 at 9:52
  • @Robert, you are right! Maybe it failed with an older Ruby version... IDK anymore. I'll update the answer. Thanks! Commented Oct 25, 2023 at 0:00
2
  def idle
    <<~aid
    This is some description of what idle does.

    It does nothing actually, it's just here to show an example of multiline
    documentation. Thus said, this is something that is more common in the
    python community. That's an important point as it's good to also fit the
    expectation of your community of work. Now, if you agree with your team to
    go with a solution like this one for documenting your own base code, that's
    fine: just discuss about it with them first.

    Depending on your editor configuration, it won't be colored like a comment,
    like those starting with a "#". But as any keyword can be used for wrapping
    an heredoc, it is easy to spot anyway. One could even come with separated
    words for different puposes, so selective extraction for different types of
    documentation generation would be more practical. Depending on your editor,
    you possibly could configure it to use the same syntax highlight used for
    monoline comment when the keyword is one like aid or whatever you like.

    Also note that the squiggly-heredoc, using "~", allow to position
    the closing term with a level of indentation. That avoids to break the visual reading flow, unlike this far too long line.
    aid
  end

Note that at the moment of the post, the stackoverflow engine doesn't render syntax coloration correctly. Testing how it renders in your editor of choice is let as an exercise. ;)

Not the answer you're looking for? Browse other questions tagged or ask your own question.