Comments: Difference between revisions
m
Remove FutureBasic apostrophe single line comment as it's deprecated
Puppydrum64 (talk | contribs) |
m (Remove FutureBasic apostrophe single line comment as it's deprecated) |
||
(47 intermediate revisions by 26 users not shown) | |||
Line 18:
=={{header|11l}}==
<
\\ Also single line comment (continuation of the comment in previous line)
Line 32:
\‘ And
this ’</
=={{header|360 Assembly}}==
<syntaxhighlight lang="360 assembly">
* An asterisk in column one denotes a comment line
* Comments may also follow any syntactically complete instruction:
Line 42:
* Comments after instructions with omitted operands require a comma ","
END , Comment (without comma, "Comment" assumed an operand of "END")
</syntaxhighlight>
=={{header|4D}}==
<
// This is a comment starting from 4D v11 and newer. Accent character is replaced by //</
=={{header|6502 Assembly}}==
Note: syntax depends on the assembler software but use of a semicolon is fairly standard
<
=={{header|68000 Assembly}}==
Line 56:
EASy68k uses * as the comment character. VASM uses a semicolon ;
<
=={{header|8086 Assembly}}==
Note: syntax depends on the assembler software but use of a semicolon is fairly standard
<
INT 21h ; BIOS interrupt 21 base 16</
=={{header|AArch64 Assembly}}==
{{works with|as|Raspberry Pi 3B version Buster 64 bits}}
<syntaxhighlight lang="aarch64 assembly">
/* ARM assembly AARCH64 Raspberry PI 3B */
/* comments multi lines
Line 73:
// comment end of ligne
</syntaxhighlight>
=={{header|ACL2}}==
Just like Common Lisp:
<
#| Multi-line
comment |#</
=={{header|Action!}}==
Action! supports only single line comments which begin with semicolon.
<
PROC Main() ;This is a comment as well
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Comments.png Screenshot from Atari 8-bit computer]
Line 93:
=={{header|Ada}}==
<
=={{header|Agena}}==
Agena has single line comments and two styles of multi-line comments.
<
#/ multi-line comment
Line 105:
/* multi-line comment - C-style
- ends with the "* followed by /" terminator on the next line
*/</
=={{header|ALGOL 60}}==
A comment in ALGOL 60 takes the place of a single instruction.
<
'COMMENT' this is a first comment;
'COMMENT'
****** this is a second comment ******
;
</syntaxhighlight>
=={{header|ALGOL 68}}==
Line 152:
===With Extensions===
£ This is a hash/pound comment for a UK keyboard £
=={{header|ALGOL-M}}==
<syntaxhighlight lang="ALGOL">
begin
comment - This form is borrowed from ALGOL 60;
% And this is borrowed from ALGOL W %
% ALGOL-M will not compile an "empty" program, so we have %
% to include at least one code-generating statement! %
write("This is only an exercise");
end
</syntaxhighlight>
=={{header|ALGOL W}}==
Line 158 ⟶ 174:
A single word in the form of an identifier following the reserved word 'end' is also a comment.
<
comment a comment;
% another comment
Line 165 ⟶ 181:
another
%
end this_word_is_also_a_comment.</
=={{header|AmigaE}}==
<
are like C ... */
-> this is a end of line comment</
=={{header|AngelScript}}==
<syntaxhighlight lang="angelscript">// This is a comment</syntaxhighlight>
=={{header|AntLang}}==
<
=={{header|Apex}}==
<
System.debug ('I will execute'); // This comment is ignored.
/*
I am a large comment, completely ignored as well.
*/
</syntaxhighlight>
=={{header|APL}}==
<syntaxhighlight lang
=={{header|AppleScript}}==
<syntaxhighlight lang="applescript">
--This is a single line comment
Line 200 ⟶ 219:
(* Nested block comment *)
*)
</syntaxhighlight>
{{works with|AppleScript|2.0}}
<
=={{header|Arendelle}}==
Line 212 ⟶ 231:
{{works with|as|Raspberry Pi}}
<syntaxhighlight lang="arm assembly">
/* ARM assembly Raspberry PI comment one line */
/* comment line 1
Line 221 ⟶ 240:
mov r1,#0 // authorized comment
</syntaxhighlight>
=={{header|Arturo}}==
<
a: 10 ; another single-line comment
; Now, this is a
; multi-line comment</
=={{header|Asymptote}}==
<syntaxhighlight lang
See [http://asymptote.sourceforge.net/doc/Programming.html programming introduction in the Asymptote manual].
Line 239 ⟶ 258:
=={{header|AutoHotkey}}==
<
/*
multiline comment1
multiline comment2
*/</
For multi-line comments, the '''/*''' and '''*/''' '''must''' be on their own separate lines. Nothing else can be on the same line.
Line 249 ⟶ 268:
=={{header|AutoIt}}==
<syntaxhighlight lang="autoit">
#cs
Everything between the cs and and the ce is commented.
Line 255 ⟶ 274:
#ce
;individual lines after a semicolon are commented.
</syntaxhighlight>
=={{header|AWK}}==
Line 261 ⟶ 280:
The ''hash'' symbol # start a comment; it ends at the end of line.
<
# do something
}</
=={{header|Axe}}==
<
<
This is a multi-line comment
...</
<
This is a comment only if the condition evaluates to zero
...</
<
This is a comment only if the condition evaluates to nonzero
...</
<
This is a comment only if the previous conditional comment was executed (and vice versa)
...</
=={{header|Babel}}==
<
-- This is a line-comment
Line 294 ⟶ 313:
dedent: 0x42 -- The comment block above is now closed
</syntaxhighlight>
=={{header|BASIC}}==
Line 306 ⟶ 325:
{{works with|GW-BASIC}}
{{works with|ZX Spectrum Basic}}
{{works with|uBasic/4tH}}
The only truly standard method of marking a comment in BASIC is using the <code>REM</code> keyword. This dates back to (at least) the late 1970's, and ''should'' work with most BASICs available today:
<
110 PRINT "this is code": REM comment after statement</
{{works with|Applesoft BASIC}}
Line 324 ⟶ 344:
{{works with|QBasic|1.1}}
{{works with|QuickBASIC|4.5}}
{{works with|uBasic/4tH}}
Most BASICs also support alternate comment characters,
commonly an apostrophe (single quote):
<
PRINT "this is code" 'comment after statement</
{{works with|DarkBASIC}}
Line 349 ⟶ 370:
==={{header|Applesoft BASIC}}===
Comment by making a REMark using the REM keyword
<
When LISTing the program a space is added after the REM keyword
<
The remark extends until the end of the line. Only the first THIS IS CODE is printed.
<
A comment can come after a GOSUB and when the subroutine returns it continues running the statements after the GOSUB comment.
<
Anything after a GOTO or RETURN statement is ignored.
<
There are other ways to add spacing and comments to code.
<
40 REM
50 :
Line 366 ⟶ 387:
70 FOR I = 1 to 10
80 ::::PRINT I;MID$("THIS IS A COMMENT",1,0)
90 NEXT</
Typing CONTinue after the program ENDs will result in a ?SYNTAX ERROR.
<syntaxhighlight lang
Use the quotation symbol " before the comment so that spaces are included and keywords are ignored.
<
==={{header|BaCon}}===
BaCon accepts '''REM''' (or single quote apostrophe) for line comments.
Line 379 ⟶ 400:
==={{header|BASIC256}}===
<
# and this is too
print "this is code" #comment after statement</
==={{header|Chipmunk Basic}}===
{{works with|Chipmunk Basic|3.6.4}}
<syntaxhighlight lang="qbasic">10 rem this is a comment
20 ' and this is too
30 print "this is code" : 'comment after statement
40 print "and more code" : rem comment after statement</syntaxhighlight>
==={{header|IS-BASIC}}===
<
110 PRINT "this is code" ! comment after statement</
==={{header|Minimal BASIC}}===
<syntaxhighlight lang="qbasic">10 REM STANDARD BASIC COMMENTS BEGIN WITH "REM" AND EXTEND TO THE END OF LINE
20 END</syntaxhighlight>
==={{header|MSX Basic}}===
<syntaxhighlight lang="qbasic">10 rem this is a comment
20 ' and this is too
30 print "this is code" : '[:] it's optional
40 print "and more code" : rem comment after statement</syntaxhighlight>
==={{header|Quite BASIC}}===
<syntaxhighlight lang="qbasic">10 rem this is a comment
20 print "this is code" : rem comment after statement</syntaxhighlight>
==={{header|True BASIC}}===
<
PRINT "this is code" !comment after statement</
==={{header|XBasic}}===
{{works with|Windows XBasic}}
{{works with|Linux XBasic}}
<syntaxhighlight lang="qbasic">PROGRAM "Comments"
VERSION "0.0000"
DECLARE FUNCTION Entry ()
FUNCTION Entry ()
'this is a comment
PRINT "this is code" 'comment after statement
END FUNCTION
END PROGRAM</syntaxhighlight>
==={{header|Yabasic}}===
<
# the hash-sign too (at beginning of line)
// even the double slash
Line 399 ⟶ 455:
print "Not a comment":// But this is again a valid comment
print "Not a comment" // even this.
print "Not a comment" rem and this !</
=={{header|Batch File}}==
<syntaxhighlight lang
There is another (undocumented) option, using a double-colon <code>::</code>. However, this has issues with some syntactic constructs and therefore may raise syntax errors.
<
:: to fail in some cases. Best avoided.</
Yet another (undocumented) option, using (not delayed) variable expansion as long as it is undefined. This works because undefined variables result to blank line when expanded using <code>%</code>.
<
Since comment lines are skipped entirely by the parser, multi-line comments aren't possible even with line continuation.
=={{header|BBC BASIC}}==
<
*| This is a comment which is compiled but ignored at run time</
=={{header|bc}}==
<
2 + /* Comment between tokens. */ 3
Line 427 ⟶ 483:
* of the comment are only for style. You must not nest a comment
* inside another comment; the first asterisk-slash ends the comment.
*/</
----
Line 433 ⟶ 489:
{{works with|OpenBSD bc}}
<
# This form of comment is an extension, not part of standard bc.
Line 443 ⟶ 499:
a = 1 # The newline is not part of the comment.
b = 2 # So this line is a different statement.</
=={{header|Beef}}==
<syntaxhighlight lang="csharp">//This is a comment.
//This is another comment.
/* This is also a comment. */
/* This is a
multi-line
comment */
</syntaxhighlight>
The IDE allows for documenting types and methods with /// or /** */ (which one of these you use doesn’t matter). Autocomplete suggestions, as well as prompts while calling/using the documented types or functions, will display their documentation.
<syntaxhighlight lang="csharp">static
{
/// Must be placed directly above the method, including attributes.
/// Using multiple lines like this is also fine. Both will be recognized.
[Optimize]
public static void DoAThing() {}
/// Documentation also works for types.
struct SomeStruct
{
/**
* Multiline comment with two ** at the start works in the same way.
*/
void PrivateMethod() {}
}
/**
* If you have a really long explainer here, you may not actually want to show that in autcompletion prompts.
* @brief Allows you to select only this line to be shown.
*
* @param a This is shown when writing a call to this function and placing parameter "a".
* @param b For the second argument, the documentation for b (this!) will show up instead.
*/
public static void DoAnotherThing(int a, int b) {}
}
</syntaxhighlight>
=={{header|Befunge}}==
Line 451 ⟶ 549:
{{works with|Befunge|93}}
<
^- inline comments -^ <-^- other comments</
{{works with|Befunge|98}}
<
^- inline comments -^ <-^- other comments
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;completely isolated comment block for the paranoid;
;(almost - you can still skip into it.) ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;</
=={{header|Binary Lambda Calculus}}==
BLC has no notion of comments, but since input is considered part of the program, one can always ignore the remainder of input, which can thus be arbitrary. Of course one can have comments in any language that translates to BLC, as discussed in https://rosettacode.org/wiki/Documentation#Binary_Lambda_Calculus
=={{header|Blast}}==
<
</syntaxhighlight>
=={{header|BQN}}==
<syntaxhighlight lang
=={{header|Bracmat}}==
Line 474 ⟶ 576:
=={{header|Brainf***}}==
<syntaxhighlight lang
Most ASCII characters may be used for comments; only the eight characters "+-<>[],." are Brainf*** commands. Extra care must be used when using punctuation, particularly the comma or period. These are I/O operators and are actually commands rather than comments, and are instead compiled into the program if used and may have to be "debugged" and removed if you forget this issue. Another workaround for this issue is to tactically place the comment inside a "[]" loop which can never be entered (The loop will only be encountered when the active memory cell value is 0).
=={{header|Brat}}==
<
#* Multi
Line
Comment *#</
=={{header|Bruijn}}==
Bruijn does not have multi-line comments.
<syntaxhighlight lang="bruijn"># This is a comment</syntaxhighlight>
=={{header|Brlcad}}==
<
# Comments in mget scripts are prefixed with a hash symbol
ls # comments may appear at the end of a line
</syntaxhighlight>
=={{header|Burlesque}}==
Line 496 ⟶ 602:
Burlesque does NOT have comments. However, you can comment code by pushing a string and popping it immediately.
<
"I'm sort of a comment"vv
</syntaxhighlight>
Since strings are multi-line strings:
<
"I'm a
very long comment spanning
over several lines"vv
</syntaxhighlight>
=={{header|C}}==
<
/* So is this
multiline comment.
*/</
The comment starts at the <tt>/*</tt>, and ends at the <tt>*/</tt>. A comment may be used between any tokens. It cannot be used inside tokens, that is, given the code
<
void f(char/* comment */isma) {}</
the function takes an argument of type char, named isma, not an unnamed argument of type charisma.
Comments cannot be nested; that is, if you write
<
the comment ends at the first <tt>*/</tt>, and <tt>inside */</tt> is again interpreted as source code (almost certainly causing a compile error). Some compilers have the option to allow nested comments, but this is not a standard feature.
Conditional compilation also can be used to make the compiler ignore some text:
<
While technically not a comment, this is also ignored by the compiler
#endif</
The trick is that 0 is always false, therefore the text between <tt>#if 0</tt> and <tt>#endif</tt> is never compiled. While this should never be used for actual comments, it's an easy way to comment out some code, especially because it doesn't interfere with normal (documentation) comments.
Conditional compile "comments" can be nested:
<
This is not compiled.
#if 0
Line 535 ⟶ 641:
#endif
And this still is not compiled.
#endif</
{{works with|ANSI}}
Even though the compiler doesn't see '''#if 0''' text, the preprocessor does. Therefore some minimal rules still have to be followed. For example, the following code is ''not'' valid:
<
This isn't valid.
#endif</
That's because the preprocessor will interpret the apostrophe as beginning of a character constant, and will complain because that character constant isn't terminated with another apostrophe.
Line 548 ⟶ 654:
{{works with|C99}}
<
=={{header|C sharp|C#}}==
<
//This is other comment.
Line 559 ⟶ 665:
/* This is a
multi-line
comment */</
=={{header|C++}}==
Line 565 ⟶ 671:
Single line C++-style comments
<syntaxhighlight lang
C++-style comments start with <tt>//</tt> and reach up to, but not including, the end of line (more exactly, up to the next unescaped newline). While formally, C++-style comments cannot be nested either, in practice they can:
<
That's because starting with the first <tt>//</tt> everything in the line is ignored, including the second <tt>//</tt>.
The fact that the newline is ''not'' part of the comment is important for multi-line macro definitions. It means that in the code
<
(macro text) // comment
(no more macro text)</
the line <tt>(no more macro text)</tt> is ''not'' part of the macro definition. Also escaping the line break at the end of the comment with '\' doesn't help, because that would make the third line part of the ''comment'' instead. Comments inside macros therefore have to be C-style.
=={{header|Chapel}}==
<
/* multi
line */</
=={{header|Chef}}==
<
This is a comment.
Line 597 ⟶ 703:
Methods.
SingleWordCommentTwo until SingleWordCommentOned.
Methods.</
=={{header|ChucK}}==
<syntaxhighlight lang="chuck">
<-- Not common
// Usual comment
</syntaxhighlight>
=={{header|Clean}}==
Clean comments are similar to C++.
<
line comment */ 17 // This is a single-line comment</
In contrast to C++ comments can be nested.
<
=={{header|Clojure}}==
Line 616 ⟶ 722:
Anything from a semicolon to the end of a line is a comment.
<
(defn foo []
123) ; also a comment</
The <code>(comment)</code> macro will prevent a form from being evaluated, returning <code>nil</code> no matter what is contained in the comment. However the forms inside the <code>comment</code> form must be properly parseable (parentheses balanced, etc.) or an exception will be thrown.
<
Finally, the <code>#_</code> reader macro will cause a form to be ignored by the reader. Unlike <code>(comment)</code>, this does not return <code>nil</code>; the surrounding code is evaluated as though the ignored form isn't even there.
<
(+ 1 #_"foo" 3) ;; Returns 4</
=={{header|CMake}}==
Line comments use the common <code>#</code> syntax:
<syntaxhighlight lang="cmake"># A single-line comment</syntaxhighlight>
Multi-line comments use a Lua-like square-bracket syntax.
<syntaxhighlight lang="cmake">
#[[A multi-line
comment ]]
#[==[A multi-line comment
with [[nested brackets]]. ]==]</syntaxhighlight>
The number of equals signs (<code>=</code>) in the opening bracket determines the number expected in the closing bracket.
=={{header|COBOL}}==
=== Fixed format ===
<
A D in the 7th column indicates a debugging line which is treated like a comment unless a compiler flag is set.
<
=== Free format ===
<
{{works with|GnuCOBOL}}
This indicates a debugging line like above, but if it is used in fixed format files, it must be in the 8th column or beyond. ''Not necessarily.'' GnuCOBOL also supports D as an indicator in column 7, the >>D format works (more by trickery than spec) if the angle brackets start in column 5, the D ending up in column 7. The >>D debug marker can then be both fixed and free form compatible.
<
=== <code>NOTE</code> statement ===
{{works with|OS/VS COBOL}}
This statement causes everything following it up to the next separator period to be treated as a comment. This statement was deleted in COBOL-74.
<
commented out and ignored
.</
=== <code>REMARKS</code> and other statements ===
Line 653 ⟶ 775:
There are quite a few <code>IDENTIFICATION DIVISION</code> obsolete and extension reserved words that will work in GnuCOBOL 2.
<syntaxhighlight lang="cobol">
IDENTIFICATION DIVISION.
PROGRAM-ID. program.
Line 665 ⟶ 787:
DATE-COMPILED. same.
DATE-MODIFIED. this one is handy when auto-stamped by an editor.
</
=={{header|CoffeeScript}}==
<
### multi
line
comment ###</
=={{header|ColdFusion}}==
In tags:
<
<!--- This is a comment. Nothing in this tag can be seen by the end user.
Note the three-or-greater dashes to open and close the tag. --->
<!-- This is an HTML comment. Any HTML between the opening and closing of the tag will be ignored, but any ColdFusion code will still run.
Note that in the popular FuseBox framework for ColdFusion, the circuit.xml files require that you use this style of comment. --></
In script:
<
// This is also a comment</
=={{header|Common Lisp}}==
Line 693 ⟶ 815:
In a common convention, header comments are prefaced with four semicolons, top-level (function level) comments use three, comments for sections of code use two, and margin comments use one.
<
;;; The foo function calls bar on the first argument and multiplies the result by the second.
Line 704 ⟶ 826:
;;; The bar function simply adds 3 to the argument
(defun bar (n)
(+ n 3))</
However, comments should not be used for inline documentation, as most defining constructs permit a documentation string (which is then available at runtime). <!-- It would be better to make the above example not do this, instead of showing bad style -->
<
"Add 3 to the argument."
(+ n 3))
Line 714 ⟶ 836:
(defclass button (widget)
(label action)
(:documentation "This is a push-button widget."))</
=={{header|Component Pascal}}==
<
(* Comments (* can nest *)
and they can span multiple lines.
*)
</syntaxhighlight>
=={{header|Crystal}}==
<
# This is a doc comment. Any line *directly* above (no blank lines) a module, class, or method is considered a doc comment
# Doc comments are used to generate documentation with `crystal docs`
class Foo
end</
=={{header|D}}==
<
// A single line comment.
Line 753 ⟶ 875:
Nestable documenttion comment.
+/
}</
=={{header|Dart}}==
<
/* This is also a valid single line comment. Unlike the first one, this one terminates after one of these -> */
Line 769 ⟶ 891:
///
/// Formatting [variable] and [function] names like so allows dartdoc to link to the documentation for those entities.
</syntaxhighlight>
=={{header|dc}}==
There is no comment syntax in POSIX dc. The convention is to make a string on the stack and move it to an unused register; a no-op.
<
GNU dc added the comment syntax of many other scripting languages.
<
=={{header|Delphi}}==
Line 781 ⟶ 903:
In addition to Pascal, Delphi also allows C++ style single line comments:
<syntaxhighlight lang
=={{header|Deluge}}==
Line 787 ⟶ 909:
Comments are only allowed in places such as "on load" scripts. You cannot put them in form or view definitions.
<syntaxhighlight lang
=={{header|Dragon}}==
<
<
This is
a multiple
line comment.
*/</
<
showln "Hello " /* This is an inline comment */ "world"
</syntaxhighlight>
=={{header|DWScript}}==
<
It may extend across multiple lines. *)
Line 814 ⟶ 936:
are supported */
// and single-line C++ style comments too</
=={{header|Dyalect}}==
<
multi-line comment */
//This is a single-line comment</
=={{header|Dylan}}==
<
/*
Line 830 ⟶ 952:
that spans multiple
lines
*/</
=={{header|Déjà Vu}}==
<
!print "this is not a comment, obviously" #this is a comment as well</
=={{header|E}}==
<
? "This is an Updoc comment, which
> is an executable example or test case.".split(" ")
# value: ["This", "is", "an", "Updoc", "comment,", "which
# is", "an", "executable", "example", "or", "test", "case."]</
All comments span to the end of the line; there are no paired-delimiter comment syntaxes. “<code>#</code>” begins a comment anywhere outside of quotes; “<code>?</code>” and “<code>></code>” begin comments only if they are at the beginning of a line (except for whitespace), because those characters are also used for infix operators.
Line 850 ⟶ 972:
=={{header|EasyLang}}==
<syntaxhighlight lang="text"># This is a comment</
=={{header|EchoLisp}}==
<
666 ; this is an end-of-line comment
Line 868 ⟶ 990:
(info 'mynumber "👀 Symbols may be commented with an information string 👺")
(info 'mynumber) → displays the above inside the 'info' field.
</syntaxhighlight>
=={{header|ECL}}==
Single-line comments must begin with //
<
Block comments must be delimited with /* and */
<
or any succeeding line – everything in between is ignored */</
=={{header|Ecstasy}}==
Comments in Ecstasy follow the two forms used by most C-family languages:
<syntaxhighlight lang="java">
/*
* This is a multi-line comment.
*/
Int i = 0; // This is an end-of-line comment
</syntaxhighlight>
=={{header|EDSAC order code}}==
EDSAC programs were handwritten on "programme sheets" designed for the purpose. The programmer, or a computer operator, then copied the "orders" (instructions) to punched tape for input to the machine. Programme sheets had a column for "notes" (comments), but these were not copied to the tape.
Modern simulators, however, accept square brackets as comment delimiters.
<
[
And so
Line 889 ⟶ 1,020:
this
]
[But in 1949 they wouldn't have been]</
=={{header|EGL}}==
Line 896 ⟶ 1,027:
=={{header|Eiffel}}==
<
=={{header|Ela}}==
<
/*multiple line
comment*/</
=={{header|Elena}}==
<
/*multiple line
comment*/</
=={{header|Elixir}}==
Elixir does not have multiple line comments.
<
# single line comment
</syntaxhighlight>
=={{header|Elm}}==
<
-- a single line comment
Line 924 ⟶ 1,055:
{- can be nested -}
-}
</syntaxhighlight>
=={{header|Emacs Lisp}}==
A comment is started by <code>;</code> and reaches to the end of the line.
<syntaxhighlight lang
There are some coding conventions for <code>;;</code> align to indentation, <code>;;;</code> sections, etc,
Line 935 ⟶ 1,066:
Another way to add comments is to use strings at places where the result of an expression is ignored, since they simply evaluate to themselves without any effect. Note that strings can be multi-line:
<
if used at a place where the result is ignored"</
Note that strings at the beginning of function definitions are interpreted as documentation strings for the function (i.e. Emacs will display them if asked for help about the function), e.g.
<
"This function subtracts its second argument from its first argument."
(- y x))</
Due to this, it's debatable if the string at that place can be considered as comment.
=={{header|EMal}}==
<syntaxhighlight lang="emal">
# This is a line comment.
^|This is a single line block comment.|^
^| This is
| a multi-line
| block comment.
|^
^|This is a ^|nested|^ block comment.|^
</syntaxhighlight>
=={{header|Erlang}}==
<
=={{header|ERRE}}==
<syntaxhighlight lang="erre">
! Standard ERRE comments begin with ! and extend to the end of the line
PRINT("this is code") ! comment after statement
</syntaxhighlight>
=={{header|Euphoria}}==
Single line comment:
<syntaxhighlight lang
Multiline C-style comment:
<syntaxhighlight lang="euphoria">/*
This is a comment
*/</
{{works with|Euphoria|4.0.0}}
=={{header|F_Sharp|F#}}==
F# accepts C++ type line comments and OCaml type block comments
<
(* this comments a region
which can be multi-line *)</
=={{header|Factor}}==
<
#! Or with "#! "
! and last until the end of the line
Line 978 ⟶ 1,123:
USE: multiline
/* The multiline vocabulary implements
C-like multiline comments. */</
=={{header|Falcon}}==
Falcon supports C-language style single line and block comments. A single line comment begins with two slashes (//) and ends at the end of the line. A block comment begins with a slash followed by an asterisk, and terminates when an asterisk followed by a slash is met (/*...*/).
<
/* Start comment block
My Life Story
Line 989 ⟶ 1,134:
// set up my bank account total
bank_account_total = 1000000 // Wish this was the case
</syntaxhighlight>
=={{header|FALSE}}==
<
=={{header|Fancy}}==
<
# and last until the end of the line
</syntaxhighlight>
=={{header|Fennel}}==
<syntaxhighlight lang="fennel">; This is a single-line comment</syntaxhighlight>
=={{header|Fermat}}==
<
{Comments within a function are enclosed within curly brackets.}
{You can make multi-line comments
Line 1,012 ⟶ 1,160:
Function Bar(n) =
2n-1.</
=={{header|Fish}}==
Since ><> is a funge-like language, all characters not touched by the command pointer or modified by the <tt>p</tt> and <tt>g</tt> commands can be comments.
Unlike Brainf***, unknown commands are not ignored by the compiler, they just raise an error.
<
>0>:n1+v all comments here
^o" "< still here
And of course here :)</
=={{header|Forth}}==
Standard Forth includes a number of ways to add comment text. As with everything in Forth, comment characters are actually words that control the compiler.
<
( The left paren skips everything up to the next right paren on the same line)</
Traditionally, the paren comments are used for "stack effect" notation:
<
This comment means "myword takes two cells on the stack and leaves one". Sometimes, stack effect comment names give clues about the word's function:
<
: strlen ( addr -- len ) count nip ;</
Some Forth systems implement other commenting words, such as these words from Win32Forth:
<
(( skips until the next double-paren,
stretching across multiple lines ))
Line 1,046 ⟶ 1,194:
enddoc
/* C-style comment */
(* Pascal-style comment *)</
=={{header|Fortran}}==
Line 1,054 ⟶ 1,202:
The first six columns in Fortran are traditionally reserved for labels and certain special characters. In particular the letter "C" in the first column indicates a comment:
<
C Usually one would avoid columns 2-6 even in a comment.</
Some Fortran compilers have the extension that comments starting with D are treated as non-comments if a special debugging flag is given at the compiler invocation. For example:
<
D PRINT *, I</
ISO Fortran 90 or later have an inline comment (!) syntax:
<
In ISO Fortran 90 or later, "C in first column" comments are only allowed in the "fixed" source form familiar to FORTRAN 77 programmers. The "free" source form only has inline comments (!).
Line 1,070 ⟶ 1,218:
ISO Fortran 95 or later has an optional conditional compilation syntax. If present, it can be used (abused?) to (in effect) comment out blocks of code:
<
do while (oh_no)
a = bad_news()
Line 1,076 ⟶ 1,224:
c = gigo()
end do
?? end if</
=={{header|FreeBASIC}}==
<
' This a single line comment
Line 1,097 ⟶ 1,245:
'/
like this
'/</
=={{header|Frink}}==
<
// This is a single-line comment
/* This is a comment
Line 1,106 ⟶ 1,254:
and so on.
*/
</syntaxhighlight>
=={{header|Futhark}}==
<syntaxhighlight lang="futhark">
-- Single-line comment
-- Multi-line
-- comment (yes, just several single-line comments).
</syntaxhighlight>
=={{header|FutureBasic}}==
<
// Single line comment
rem Single line comment
/* Single line comment */
Line 1,128 ⟶ 1,275:
comment
*/
</syntaxhighlight>
=={{header|FUZE BASIC}}==
<
# Comment (Space required)
REM Comment (Space require)
PRINT "This is an inline comment."//Comment (No space required)
END</
=={{header|Gambas}}==
Line 1,141 ⟶ 1,288:
In gambas, comments can be inserted by prefixing them with an apostrophe. The gambas interpreter will ignore the apostrophe and any other characters that follow it until the end of the line:
<
' This whole line is a comment and is ignored by the gambas interpreter
print "Hello" ' Comments after an apostrophe are ignored
Line 1,148 ⟶ 1,295:
' FIXME: Fix Me comment will appear in Task Bar
' NOTE: Note commnet will appear in Task Bar
</syntaxhighlight>
=={{header|GAP}}==
<
=={{header|gecho}}==
<
=={{header|Gema}}==
<
A shebang (#!) may be used as a comment in the first line of a file.
=={{header|Genie}}==
Genie allows comments in code in two different ways.
<
/* Comment lasts between delimiters */</
Delimited comments cannot be nested.
Line 1,170 ⟶ 1,317:
=={{header|GML}}==
single-line comment:
<
multi-line comment:
<
ends with asterisk-slash.
also note:
* A multi-line comment is ignored inside a string
* A multi-line comment can be ended inside a line
*/</
=={{header|gnuplot}}==
<
# backslash continues \
a comment to the next \
line or lines</
The way backslash continues a comment means that comments can't usefully be put within a multi-line function definition,
<
foo(n) = (n \
+ 2 # no good \
Line 1,195 ⟶ 1,342:
# behaves as if you wrote merely
foo(n) = (n+2</
=={{header|Go}}==
<
/* this is
a multi-line
block comment.
/* It does not nest */</
=={{header|Golfscript}}==
<syntaxhighlight lang
=={{header|Gri}}==
<code>#</code> through to newline.
<
show 123 # this too is a comment</
<code>//</code> works similarly but is reckoned the "old way" (as of Gri 2.12.23)
<syntaxhighlight lang="text">// this is a comment
show 123 // this too is a comment</
Both forms can be used in input data files too.
Line 1,226 ⟶ 1,373:
{{works with|GW-BASIC}}
<
110 PRINT "this is code": REM comment after statement</
=={{header|Haskell}}==
<
{- I am also
Line 1,244 ⟶ 1,391:
This is a Haddock documentation block comment
-}
i code = True</
=={{header|Haxe}}==
<
/*
Line 1,253 ⟶ 1,400:
line
comment.
*/</
=={{header|HicEst}}==
<
=={{header|Hope}}==
<
=={{header|HTML}}==
<
=={{header|Icon}} and {{header|Unicon}}==
Any text after "#" is a comment.
<
procedure x(y,z) #: This is a comment and an IPL meta-comment for a procedure
</syntaxhighlight>
The [[:Category:Icon_Programming_Library|The Icon Programming Library]] established conventions for commenting library additions and functions. This included both header block comments and meta comments on procedures within library files.
Line 1,276 ⟶ 1,423:
The comment character in IDL is the semicolon - everything starting with it and to the end of the line is a comment. Like this:
<
fact = product(indgen( n )+1) ; where n should be an integer</
=={{header|Inform 7}}==
<
[This is a
multi-line comment.]
[Comments can [be nested].]</
=={{header|Insitux}}==
<syntaxhighlight lang="insitux">
;this is a comment; and using semicolons here is fine
(+ 2 2) ;this is a comment
"this string will be ignored if in the top scope
which can also stretch across
multiple lines"
(do "if you're desperate, using do will make sure this string will not be returned also"
(+ 2 2))
</syntaxhighlight>
=={{header|Intercal}}==
<
=={{header|Io}}==
<
// Single-line comment
/* Multi-line
comment */</
=={{header|Isabelle}}==
<
imports Main
begin
Line 1,305 ⟶ 1,466:
(* Top-level Isar comment. *)
end</
=={{header|J}}==
<
'Character strings in J may have their value be ignored and treated as comment text.'
0 : 0
Line 1,320 ⟶ 1,483:
)
{{)n
J release 9's nestable blocks can be used as comments.
Typically, this would be in contexts where the blocks would not be used.
That said, "literate coding practices" may stretch the boundaries here.
Also, noun blocks (beginning with ')n') avoid syntactic concerns about content.
These blocks even allow contained '}}' sequences to be ignored (unless, of
course the }} character pair appears at the beginning of a line).
}}</syntaxhighlight>
=={{header|Java}}==
Java has two ways to enter normal comments, plus a third type of comment that doubles as a way to generate HTML documentation.
===C Style===
<
<
* This is
* a multiple
* line comment.
*/</
This ''C-style'' comment starts with <tt>/*</tt> and ends with <tt>*/</tt>.
The two delimiters may be on the same or separate lines.
This style comment may be used anywhere white space is permitted.
===C++ Style (inline)===
<syntaxhighlight lang
This ''C++-style'' comment starts with <tt>//</tt> and extends to the end of line.
===Java Documentation (Javadoc)===
<
<
* This is
* a multiple
* line Javadoc comment
*/</
[http://en.wikipedia.org/wiki/Javadoc Javadoc] is a standardized documentation code for Java. Its comments begin with a forward slash and two stars. Javadoc comments have different tags that signify different things in the methods and classes that they precede.
===Sneaky===
Your editor will probably colour this as great big comment, but it compiles and prints "Hello World!". Once you've figured out how this works, try this [http://stackoverflow.com/questions/4448180/why-does-java-permit-escaped-unicode-characters-in-the-source-code discussion on why it's allowed].
<
/*
\u002A\u002F\u0070\u0075\u0062\u006C\u0069\u0063\u0020\u0073\u0074\u0061\u0074\u0069\u0063
Line 1,360 ⟶ 1,533:
\u002B\u0022\u0020\u0057\u006F\u0072\u006C\u0064\u0021\u0022\u0029\u003B\u007D\u002F\u002A
*/
}</
=={{header|JavaScript}}==
<
<
<
a multi line
comment
// with a "nested" comment
and another line in the comment
*/</
=={{header|JCL}}==
first form
<syntaxhighlight lang="jcl">
//* This is a comment line (//* in columns 1-3)
</syntaxhighlight>
second form
<syntaxhighlight lang="jcl">
/* This is also a comment line (/* in columns 1-3)
</syntaxhighlight>
=={{header|Joy}}==
<
(* this is a
multi-line comment *)</
Multi-line comments cannot be nested.
Line 1,392 ⟶ 1,565:
=={{header|jq}}==
Except when a hash symbol (#) appears within a string, it begins a comment that continues to the end of the line:
<
"Hello #world" # the first # on this line is part of the jq program
</syntaxhighlight>
=={{header|Jsish}}==
<
/* Comments, in Jsish */
Line 1,424 ⟶ 1,597:
PASS!: err = can not execute expression: 'noname' not a function
=!EXPECTEND!=
*/</
{{out}}
Line 1,438 ⟶ 1,611:
=={{header|Julia}}==
<
#=
Line 1,444 ⟶ 1,617:
line
comment
=#</
=={{header|K}}==
<
2+2 / as is this
</syntaxhighlight>
=={{header|KonsolScript}}==
<
//This is another comment.
Line 1,460 ⟶ 1,633:
/* This is a
multi-line
comment */</
=={{header|Kotlin}}==
<
/*
Line 1,493 ⟶ 1,666:
println("Current stable version is $CURRENT_VERSION")
println("Next major version is $NEXT_MAJOR_VERSION")
}</
=={{header|Lambdatalk}}==
<
Out of bracketed expressions words are ignored by the lambdatalk evaluator and are dislayed as they are:
Hello World
-> Hello World
In order to prevent any evaluation and display of some parts of code put them inside triple degrees "°°°":
°°°
this is
a comment ... and an expression {+ 1 2}
on several lines
°°°
</syntaxhighlight>
=={{header|LabVIEW}}==
{{VI solution|LabVIEW_Comments.png}}
=={{header|Lang}}==
Single line
<syntaxhighlight lang="lang5">
# This is a comment
</syntaxhighlight>
Multiline (Line continuation)
<syntaxhighlight lang="lang5">
# This is a comment\
with multiple lines
</syntaxhighlight>
Multiline (Multiline text sequence)
<syntaxhighlight lang="lang5">
# {{{This is a comment
which has more than
2 lines
and this one}}}
</syntaxhighlight>
=={{header|Lang5}}==
<syntaxhighlight lang
=={{header|langur}}==
Langur has 2 types of comments.
<
/* inline or multi-line comment uses C-style syntax */
</syntaxhighlight>
=={{header|Lasso}}==
<
/* This is also a comment. */
Line 1,534 ⟶ 1,731:
A multi-line
comment
=========================== */</
=={{header|LaTeX}}==
In LaTeX, comments look like this:
<
\begin{document}
% This is a comment
\end{document}</
LaTeX comments start with <tt>%</tt> and continue up to ''and including'' the line break. The fact that the line break itself is commented out as well makes it useful for adding line breaks in the source code of complex macros without LaTeX interpreting them (which may cause extra space or even a paragraph break in the resulting typeset text). For example, the following results in the ''one'' word "understandable":
<
\newcommand{\firstpart}[1]{under#1}
\newcommand{\secondpart}{able}
Line 1,551 ⟶ 1,748:
\begin{document}
\complete
\end{document}</
Without the percent sign after <tt>\firstpart{stand}</tt>, it would have been the ''two'' words "understand able".
=={{header|Liberty BASIC}}==
<
REM This is a comment
print "This has a comment on the end of the line." 'This is a comment
print "This also has a comment on the end of the line." : REM This is a comment</
=={{header|Lily}}==
There are two kinds of comments:
<
and
<
is
a
block
comment ]#</
Like with C, block comments don't nest.
Line 1,578 ⟶ 1,775:
=={{header|Lilypond}}==
<
%{ This is a comment
spanning several lines %}</
=={{header|Lingo}}==
In Lingo any line starting with "--" is a comment and ignored by the interpreter.
<
-- This is another comment</
=={{header|LiveCode}}==
<
// comment may appear anywhere on line
# comment may appear anywhere on line
/* this is a
block comment that
may span any number of lines */</
=={{header|Logo}}==
<
=={{header|Logtalk}}==
<
<
comment */</
=={{header|LOLCODE}}==
<
multi line comment
TLDR</
<
=={{header|LotusScript}}==
LotusScript has two ways to enter comments.
<syntaxhighlight lang
Wherever the single quote (<tt>'</tt>) is used, the rest of the line is treated as a comment and ignored. Multi-line comments would each need a single quote mark. This style of comment is usually used for making small in-line or single line comments.
<
This is a multi-
line comment.
%END REM</
A <tt>%REM</tt> marker begins a comment block, and a <tt>%END REM</tt> marker ends the comment block. This style of comment is used for making longer multi-line comments, often at the beginning of a class, sub or function.
=={{header|LSE}}==
<
(* Ceci est un commentaire sur plusieurs lignes
Line 1,628 ⟶ 1,825:
plusieurs lignes justement... *)
(* Cette exemple est selon la revision LSE-2000 *)</
=={{header|LSE64}}==
<
The author of LSE64 comments the stack effect of words with header comments as follows:
<
=={{header|Lua}}==
<
--[[A multi-line
comment --]]</
{{works with|Lua|5.1 and above}}
<
]====]</
=={{header|M2000 Interpreter}}==
Multiline commend Ret { lines of code, or text }
Same line comment until end of line (can start immediate after a command: use ' or \ or //
Rem (form start of code line)
(:\ and \\ or \) in a name can exist only for Dir statement:
dir c:\thatfolder
is the same as
dir "c:\thatfolder"
<syntaxhighlight lang="m2000 interpreter">
Module Comments {
Rem {
Print "no print here"
? "no print here either"
}
Rem : single line remark
// single line
\ single line
' single line
? "ok" : Rem : Print "not print - but code have syntax highlight"
? "ok" // single line - start without double colon
? "ok" \ single line - start without double colon
Print "ok" ' single line
}
Comments
</syntaxhighlight>
=={{header|M4}}==
<
dnl this text completely disappears, including the new line
Line 1,672 ⟶ 1,887:
Everything diverted to -1 is processed but the output is discarded.
A comment could take this form as long as no macro names are used.
divert</
{{out}}
Line 1,681 ⟶ 1,896:
can separate it from preceding text if necessary
<
<code>changecom()</code> can set a different character for <code>#</code>,
<
% now percent prevents macro expansion</
In GNU m4 an empty <code>changecom()</code> string means no such commenting char at all (but in BSD m4 means reset to the default <code>#</code>)
<
GNU m4 now no macro expansion suppression character at all</
In GNU m4 <code>changecom()</code> also takes separate start and end strings and they can be multi-character sequences, allowing for example C style,
<
/* GNU m4 now no macro expansion in C style comments */</
=={{header|Maple}}==
<
17; (* This
is
a multiline comment *) 23.4;</
{{out}}
<pre>
Line 1,712 ⟶ 1,927:
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<syntaxhighlight lang
It can be used everywhere and nested if necessary:
<
evaluates to:
<
=={{header|MATLAB}}==
<
%% Two percent signs and a space are called a cell divider</
=={{header|Maxima}}==
<
/* Nested comment */
*/</
=={{header|MAXScript}}==
<
/* This is a
multi-line comment */</
=={{header|MBS}}==
<
INT n:=5 ! Comments can appear at the end of a line
/* A comment block can also be defined using climbstar and starclimb symbols.
This allows comments to be stretched across several lines */</
=={{header|MEL}}==
<syntaxhighlight lang="mel">// This is a single line comment</syntaxhighlight>
=={{header|Metafont}}==
<
=={{header|Microsoft Small Basic}}==
Microsoft Small Basic uses the quote symbol to mark it's comments. After placing a quote everything in that line will be ignored.
<
i = i + 1 ' You can also append comments to statements</
=={{header|min}}==
{{works with|min|0.19.3}}
<
1 1 + ; add one and one together</
=={{header|MiniScript}}==
MiniScript just has one kind of comment. They begin with two slashes, and extend to the
end of a line. So you can put a comment either on a line by itself, or after a statement.
<syntaxhighlight lang="miniscript">// How many roads must a man walk down?
x = 6 * 7 // forty-two</syntaxhighlight>
=={{header|Mirah}}==
<
/* This is
* a multiple
* line comment */
</syntaxhighlight>
=={{header|MIPS Assembly}}==
This is ultimately up to the assembler, but semicolons are typically the comment character for almost all assemblers.
<
li $t0,0x1234 ;this is also a comment</
However, MARS and QTSPIM use the <code>#</code>.
<syntaxhighlight lang="mips"># this is a comment
li $t0,0x1234 # this is also a comment</syntaxhighlight>
=={{header|mIRC Scripting Language}}==
<
/*
Multiple
Line
Comment
*/</
=={{header|Modula-2}}==
<
and they can span multiple lines.
*)</
=={{header|Modula-3}}==
<
and they can span multiple lines.
*)</
=={{header|Monte}}==
<syntaxhighlight lang="monte">
# This comment goes to the end of the line
/** This comment is multi-line.
Line 1,795 ⟶ 2,024:
and ends with only one.
These should only be used for docstrings. */
</syntaxhighlight>
=={{header|MontiLang}}==
<syntaxhighlight lang="montilang">
/# This is a comment #/
/#
comments can span multiple lines
nested comments are not supported #/
</syntaxhighlight>
=={{header|MOO}}==
<
// Some compilers will, however, compile // one-liners to string literals as well (and vice-versa)
/* Classical C-style comments are removed entirely during compile */</
=={{header|Nanoquery}}==
Comments in Nanoquery must be on a single line.
<
// this is also a comment</
=={{header|NATURAL}}==
<
=={{header|Neko}}==
<
/*
Line 1,829 ⟶ 2,058:
Documentation block
<doc>can include XML parsed nodes between doc tags</doc>
**/</
=={{header|Nemerle}}==
<
/* This
is
a
multiline
comment */</
=={{header|NESL}}==
<
=={{header|NetRexx}}==
NetRexx supports block-comments and line comments. Block comments are started with a <code>'''/*'''</code> and terminated with a <code>'''*/'''</code>. Line comments follow a <code>'''--'''</code> sequence anywhere on a line.
NetRexx supports nested comments (see [[#REXX|REXX]]).
<syntaxhighlight lang="netrexx">/*
NetRexx comment block
Line 1,853 ⟶ 2,082:
-- NetRexx line comment
</syntaxhighlight>
=={{header|NewLISP}}==
A comment is started by <code>;</code> and reaches to the end of the line.
<syntaxhighlight lang
=={{header|Nim}}==
<
var x = 0 ## Documentation comments start with double hash characters.
Line 1,875 ⟶ 2,104:
discard """This can be considered as a "comment" too
This is multi-line"""
</syntaxhighlight>
=={{header|Nix}}==
<
/* This
is
a
multiline
comment */</
=={{header|NSIS}}==
<
# This is a comment that goes from the # to the end of the line.
; This is a comment that goes from the ; to the end of the
Line 1,893 ⟶ 2,122:
multi-line
comment */
</syntaxhighlight>
=={{header|Oberon-2}}==
<
(* this is a comment *)
(*
Line 1,903 ⟶ 2,132:
(* with a nested comment *)
*)
</syntaxhighlight>
=={{header|Objeck}}==
<
#This is a comment.
# This is other comment.
Line 1,915 ⟶ 2,144:
multi-line
comment ~#
</syntaxhighlight>
=={{header|Objective-C}}==
Line 1,922 ⟶ 2,151:
=={{header|OCaml}}==
<
(* containing nested comment *)
*)
(** This an OCamldoc documentation comment *)</
=={{header|Octave}}==
<
% I am a comment till the end of line
Line 1,936 ⟶ 2,165:
multiple lines
%}
</syntaxhighlight>
=={{header|Oforth}}==
Oforth has only single line comment (inside or outside definition)
<
=={{header|ooRexx}}==
Comments in ooRexx follow the same rules as [[#REXX|REXX]] and [[#NetRexx|NetRexx]]
<syntaxhighlight lang="oorexx">/*
Multi-line comment block
*/
Line 1,956 ⟶ 2,185:
hour = 12 /* time for lunch! works as well (and really everywhere) */
</syntaxhighlight>
=={{header|Openscad}}==
The openscad geometry compiler supports C++ style comments:
<
// This is a single line comment
Line 1,969 ⟶ 2,198:
*/
</syntaxhighlight>
=={{header|OxygenBasic}}==
<
' Basic line comment
; Assembly code line comment
// C line comment
/* C block comment */
</syntaxhighlight>
=={{header|Oz}}==
<
%% often with double "%" because then the indentation is correct in Emacs
Line 1,987 ⟶ 2,216:
comment
*/
</syntaxhighlight>
=={{header|PARI/GP}}==
Line 1,993 ⟶ 2,222:
=={{header|Pascal}}==
<
It may extend across multiple lines. *)
Line 2,002 ⟶ 2,231:
but not valid in [[Turbo Pascal]]. }
{ The same is true in this case *)</
In Pascal, comments cannot be nested.
Line 2,008 ⟶ 2,237:
=={{header|PASM}}==
<
print "Hello\n" # This is also a comment
end</
=={{header|Peloton}}==
Peloton encloses all comments inside <@ OMT></@> (fixed length opcode) or <# OMIT></#> (variable length opcode) whether single- or multi- line.
<
<@ OMT>This is a
multiline
comment</@>
</syntaxhighlight>
OMT suppresses evaluation of everything contained. There are a variety of extra opcodes which can be used to control how OMT functions at run time.
Line 2,025 ⟶ 2,254:
Single line comment
<syntaxhighlight lang
These may also be at the end of a line
<
Multi-line comments for inline documentation (Plain Old Documentation, or POD in Perl parlance) follow the format:
<
Here are my comments
this is multi-line
=cut</
Note that technically, both of the lines beginning with the equals sign must be surrounded on either side for compatibility with all "POD" parsers.
Line 2,044 ⟶ 2,273:
Note also that any string beginning with an equals sign, and that appears in the initial column of a line, begins a multi-line comment. It does not have to be a POD "command:" the following are all valid:
<
=head4
=over 4
=Any Old String</
Such blocks always end in =cut.
Line 2,056 ⟶ 2,285:
{{libheader|Phix/basics}}
Single line comment:
<!--<
<span style="color: #000080;font-style:italic;">--
// this is also a comment. </span>
<!--</syntaxhighlight>-->
Nestable multiline comments:
<!--<
<span style="color: #000080;font-style:italic;">/*
This is a comment
Line 2,072 ⟶ 2,302:
*/</span>
<span style="color: #7060A8;">puts<span style="color: #0000FF;">(<span style="color: #000000;">1<span style="color: #0000FF;">,<span style="color: #008000;">"this is not a comment"<span style="color: #0000FF;">)
<!--</
{{out}}
<pre>
this is not a comment
</pre>
In fact there are now a total of six(!) different types of comment in Phix:
#! opening shebang
#[ .. #] for multiline shebangs
-- standard line comments
// C-style line comments
/* .. */ standard nestable multiline comments
--/* .. --*/ Euphoria-compatibility-style nestable multiline comments/code
=={{header|PHP}}==
Single line comment:
<
// this is commented</
These may also be at the end of a line:
<
$var = 1; // this is the comment part</
Basic syntax for multi-line comments:
<
Here are my comments
this is multi-line
*/</
Note that; it is more common to see phpDocumentor styled multi-lined comments:
<
* phpdoc Comments
* @todo this is a todo stub
*/</
=={{header|Picat}}==
{{works with|Picat}}
<syntaxhighlight lang="picat">
/*
* Multi-line comment
Line 2,111 ⟶ 2,348:
% Single-line Prolog-style comment
</syntaxhighlight>
=={{header|PicoLisp}}==
<
#{
This is a
Line 2,125 ⟶ 2,362:
This is typically used conditionally, with a read-macro expression like
`*Dbg
so that this text is only read if in debugging mode.</
=={{header|Pike}}==
<
/* This is a
multi
Line 2,134 ⟶ 2,371:
comment */
int e = 3; // end-of-statement comment.</
=={{header|PL/I}}==
<
<
This is a multiline comment.
*/</
Note: In PL/I, comments cannot be nested.
Line 2,146 ⟶ 2,383:
Single line comment:
<
Multiline comment:
<
this is a multiline
comment
*/</
End of line comment:
<
=={{header|Plain English}}==
<
Put 1 plus [there are inline comments too] 1 into a number.</
=={{header|plainTeX}}==
Line 2,169 ⟶ 2,406:
it; so the % starts a to-end-of-line comment in many TeX macro packages.
<
This is not.</
The final newline character is eaten and since it normally behaves like a space, the comment can
be used to hide the newline:
<
\def\secondpart{able}
\def\complete{\firstpart{stand}%
\secondpart}
\complete</
Outputs <tt>understandable</tt>; without % it would output <tt>understand able</tt>.
Line 2,189 ⟶ 2,426:
begins with tree consecutive semicolons and ends at the end of line:
<
C-like comments may be multiline:
<
Second line */</
C-like comments (unlike C) may be nested:
<
One can also use conditional compilation to comment out sections of code
<
some code
#_ENDIF</
however, commented out part must consist of valid Pop11 tokens. In particular, C-like comments must balance and strings must be terminated.
The following is an error:
<
This w'ont work
#_ENDIF</
because apostrophe starts an unterminated string.
=={{header|PostScript}}==
<syntaxhighlight lang="text">
%This is a legal comment in PostScript
</syntaxhighlight>
=={{header|PowerShell}}==
<syntaxhighlight lang
{{works with|PowerShell|2}}
<
comment #></
=={{header|Processing}}==
<
/* a multi-line
Line 2,243 ⟶ 2,480:
// comment at the end of a line
println("foo bar"); // "baz"</
==={{header|Processing Python mode}}===
<
"""
Line 2,262 ⟶ 2,499:
println("foo bar") # "baz"
# there is no way to make an inline comment</
=={{header|ProDOS}}==
I don't know why this is even a task because it should be included in any decent programming language.
<syntaxhighlight lang
=={{header|Prolog}}==
<
<
multi-line comment */</
=={{header|PureBasic}}==
PureBasic uses the ";" symbol to mark its comments. All text entered after ";" on a line is ignored by the compiler.
<
foo = 5 ;This is a comment
c$ = ";This is not a comment" ;This is also a comment</
=={{header|Python}}==
Python uses the "#" symbol to mark it's comments. After placing a "#", everything to the right of it in that line will be ignored.
<
foo = 5 # You can also append comments to statements</
Certain 'do nothing' expressions resemble comments
<
as multi-line comments
"""
Line 2,295 ⟶ 2,532:
of other quote marks without any need to \escape\ them using any special characters. They also may span multiple
lines without special escape characters.
'''</
Note that strings inserted among program statements in Python are treated as expressions (which, in void context, do nothing). Thus it's possible to "comment out" a section of code by simply wrapping the lines in "triple quotes" (three consecutive instances of quotation marks, or of apostrophes, and terminated with a matching set of the same). Using unassigned strings as comments is frowned on and may also trigger certain linters.
Line 2,302 ⟶ 2,539:
Python makes pervasive use of strings which immediately follow class and function definition statements, and those which appear as the first non-blank, non-comment line in any module or program file. These are called "documentation" strings or "docstrings" for short; and they are automatically associated with the '''__doc__''' attribute of the class, function, or module objects in which they are defined. Thus a fragment of code such as:
<
# Example of using doc strings
"""My Doc-string example"""
Line 2,318 ⟶ 2,555:
print (Foo.__doc__)
print (Foo.__init__.__doc__)
print (bar.__doc__)</
Line 2,328 ⟶ 2,565:
=={{header|Quackery}}==
<syntaxhighlight lang="quackery">
( The word "(" is a compiler directive (a builder,
in Quackery jargon) that causes the compiler to
Line 2,350 ⟶ 2,586:
The word "commentary" will cause the compiler to
disregard everything that comes after it to the
end of the source string or file.</
=={{header|QB64}}==
''CBTJD'': 2020/03/12
<
' This is also a remark...
Line 2,365 ⟶ 2,601:
REM $STATIC 'arrays cannot be resized once dimensioned.
REM $DYNAMIC 'enables resizing of array dimensions with REDIM.
REM $INCLUDE: 'loads a reference file or library.</
=={{header|R}}==
<syntaxhighlight lang
=={{header|Racket}}==
<syntaxhighlight lang="racket">; this is a to-end-of-line coment
#| balanced comment, #| can be nested |# |#
Line 2,379 ⟶ 2,614:
#; ; the following expression is commented because of the #; in the beginning
(ignored)</syntaxhighlight>
=={{header|Raku}}==
Line 2,390 ⟶ 2,623:
A single-line comment starts with # and extends to the end of the line.
<syntaxhighlight lang="raku"
my $x = 42;</
'''Multi-line comments'''
Line 2,397 ⟶ 2,630:
A multi-line comment starts with #` and followed by the commented text enclosed by bracketing characters (e.g., (), [], {}, 「」, etc.).
<syntaxhighlight lang="raku"
Comments beginning with a backtick and one or more opening bracketing characters are embedded comments.
They can span more than one line…
)
my $y = #`{ …or only part of a line. } 3;</
Multi-line comments can also be embedded into code.
<syntaxhighlight lang="raku"
say #`(or print element) $_ #`(with a newline);
}</
Using more than one bracketing character lets you include an unmatched close bracket, as shown below.
<syntaxhighlight lang="raku"
This close curly brace } won't terminate the comment early.
}}</
'''Pod comments'''
<syntaxhighlight lang="raku"
Pod is the successor to Perl 5's POD. This is the simplest way to use it for multi-line comments.
For more about Pod, see Pod: https://docs.perl6.org/language/pod
=end comment</
Pod also provides declarator blocks which are special comments that attach to some source code and can be extracted as documentation. They are either #| or #= and must be immediately followed by either a space or an opening curly brace. In short, blocks starting with #| are attached to the code after them, and blocks starting with #= are attached to the code before them.
<syntaxhighlight lang="raku"
sub distance(
Rat \x1, #= First point's abscissa,
Line 2,435 ⟶ 2,668:
){
return sqrt((x2 - x1)**2 + (y2 - y1)**2)
}</
=={{header|Rapira}}==
Comments in Rapira are preceded by a backslash (\).
<syntaxhighlight lang="rapira">\ This is a Rapira comment.</syntaxhighlight>
=={{header|Raven}}==
<syntaxhighlight lang="raven"> # this is a comment</syntaxhighlight>
=={{header|REBOL}}==
<syntaxhighlight lang="rebol">; This is a line comment.
{ Multi-line strings can
be used as comments
if you like }
</syntaxhighlight>
Functions have special commenting options which make them self documenting:
<syntaxhighlight lang="rebol">
plus2: func [
"Adds two to a number."
Line 2,460 ⟶ 2,694:
n + 2
]
</syntaxhighlight>
If you say "help plus2" at REBOL's REPL, you'll get this help information:
Line 2,475 ⟶ 2,709:
=={{header|Relation}}==
<syntaxhighlight lang="relation">
// This is a valid comment
// A space is needed after the double slash
</syntaxhighlight>
=={{header|Retro}}==
<
=={{header|REXX}}==
Line 2,494 ⟶ 2,728:
Also, some REXX interpreters show the comment (if part of a REXX statement) as part of the information displayed when (if) a '''syntax''' error occurs and an informative error message is generated. For instance, in the program (named c:\COMMENTD.REX):
<
y=7
say 44 / (7-y) /* divide by some strange thingy.*/</
'''output''' when using the Regina REXX interpreter:'
<pre>
Line 2,520 ⟶ 2,754:
<br>Nested comments allow an easy way to comment large chunks of code where the commented-out code has its own comments.
<
/* everything between a "climbstar" and a "starclimb" (exclusive of literals) is
Line 2,561 ⟶ 2,795:
/*not a real good place for a comment (above),
but essentially, a REXX comment can be
anywhere whitespace is allowed. */</
A Classic REXX implementation (e.g. Regina) also allow line comments which start with a '''--''' sequence and extend to the end of the line:
Line 2,580 ⟶ 2,814:
<
say "something" -- another line comment (maybe)</
It should be noted that the above type of comments are not part of Classic REXX, nor are they described nor sanctioned in the REXX ANSI standard.
=={{header|Ring}}==
in Ring language we can use // or # for one line comments:
<
//this is a single line comment
#this also a single line comment!
</syntaxhighlight>
and for multi-line comments we use /* */:
<
/*This is a multi-line
comment that will be completely
ignored by the compiler/interpreter
*/
</syntaxhighlight>
=={{header|RLaB}}==
Line 2,603 ⟶ 2,837:
RLaB only has single line comment indicator, as in following examples
<syntaxhighlight lang="rlab">
x = "code" # I am a comment
x = "code" // Here I comment thee
# matlab-like document line
// C++ like document line
</syntaxhighlight>
=={{header|Robotic}}==
Comments can only be created in one way:
<
. "This is a comment line"
Line 2,619 ⟶ 2,853:
. "This is the only way to comment a line in Robotic"
</syntaxhighlight>
Although these are comments, the interpreter doesn't completely ignore it. For one, the code speed can be affected if they are ever encountered. Also, if an @ character exists at the beginning of the comment line, then the rest of the string after it is now the Robot's new name (there is a 14 character limit).
Example of changing the robot's name:
<
. "@NewRobotName"
</syntaxhighlight>
This would then change the robot's name from whatever it was before to "NewRobotName" instead.
=={{header|Rockstar}}==
<syntaxhighlight lang="rockstar">Rockstar is cool.
(Rockstars don't like comments, but if you really really want to, you write them in parentheses and they are believed to be multiline. In fact, parentheses are just the comment symbols, so you can't even use parentheses in math, so if you want the addition to happen before the multiplication, do the addition and assign it to a variable. And by the way, the Rockstar is cool line assigned the number 4 to the variable Rockstar, because cool is four letters and all that. And this comment has gone on way too long for a language with a developer community that hates comments.)
Shout Rockstar.
(Might as well put that number 4 on the screen.)</syntaxhighlight>
=={{header|RPL}}==
Although its code can sometimes be difficult to read due to stack operations, basic RPL does not provide any functionality to comment out. The only solution is then to insert strings and delete them immediately, such as:
≪
SWAP - <span style="color:grey">"swap the first 2 levels and subtract" DROP</span>
≫
From 1993, comments can be added in a source code written with a text editor on a computer, starting with an @ and ending by either another @ or a newline character, before transfer to and compilation by the calculator. The compilation step removes all comments.
≪
SWAP - <span style="color:grey">@ swap the first 2 levels and subtract </span>
≫
=={{header|Ruby}}==
<
=begin hello
I a POD documentation comment like Perl
=end puts "code"</
=={{header|Run BASIC}}==
Comments have a ' (single quote) or REM for remarks
<
REM This is a comment
print "Notice comment at the end of the line." 'This is a comment
print "Also notice this comment at the end of the line." : REM This is a comment
</syntaxhighlight>
=={{header|Rust}}==
<
/*
Line 2,686 ⟶ 2,935:
(inner attributes are terminated by a semi-colon)
See also https://github.com/mozilla/rust/blob/master/doc/rust.md#attributes"];
}</
=={{header|SAS}}==
<
*another comment;
Line 2,696 ⟶ 2,945:
may
be
multiline;</
=={{header|Sather}}==
<syntaxhighlight lang
=={{header|S-BASIC}}==
<syntaxhighlight lang="BASIC">
rem S-BASIC of course allows traditional BASIC-style comments
comment
In addition to the single-line REM statement, S-BASIC
also supports multiline comments using COMMENT...END.
Note that the terminating END must be the first token on
a line of its own.
end
comment
When declaring a group of variables, S-BASIC allows
a semi-colon, instead of the normal comma, as a separator,
in which event an explanatory comment can follow the
semi-colon and is ignored by the compiler.
end
var n ; number of payments over life of loan
ppy ; payments per year
apr ; annual interest rate as a decimal
amt ; principal amount of loan
pmt ; amount of periodic payment
= real
comment
Finally, although statements in S-BASIC are normally terminated
by an end-of-line, any logical statement can be continued on to
the following physical line with a backslash, in which event
anything after the backslash is ignored and can be used for
a comment.
end
if amt = 0 then \ user forgot to enter a value
print "Must specify a loan amount!"
end
</syntaxhighlight>
=={{header|Scala}}==
<
/* A multi-line
comment */</
=={{header|Scheme}}==
<
; While R5RS does not provide block comments, they are defined in SRFI-30, as in Common Lisp :
Line 2,718 ⟶ 3,005:
; See http://srfi.schemers.org/srfi-30/srfi-30.html
</syntaxhighlight>
=={{header|Scilab}}==
Specify a comment starting with // to the end of line
<syntaxhighlight lang="text">// this is a comment
i=i+1 // this is a comment</
=={{header|sed}}==
<syntaxhighlight lang
=={{header|Seed7}}==
<
(* A multi-line
Line 2,736 ⟶ 3,023:
(* In Seed7,
(* comments can be nested. *) *)</
=={{header|SenseTalk}}==
<
# Hashtag is a comment
-- Dash dash is another comment
Line 2,747 ⟶ 3,034:
blocks of code (* and can be nested *) *)
set foo to true // all comments can append to statements
</syntaxhighlight>
=={{header|Set lang}}==
<
set a 0 > Comments may start after a Set command</
=={{header|SETL}}==
<
$ For nostalgic reasons, this is also a comment.</
=={{header|Sidef}}==
Single line comment
<syntaxhighlight lang
These may also be at the end of a line
<
Embedded comments
<
say distance; # prints: 3000</
Multi-line comments
<
This is a multi-line comment
*/</
=={{header|Simula}}==
The same as Algol 60:
<syntaxhighlight lang="text">COMMENT This is a comment for Simula 67;</
And an new form:
<syntaxhighlight lang="text">!This is a comment for Simula 67;</
'''Pitfall''': it's ''not'' easy to ''comment-out'' parts of code:
<
=={{header|Slate}}==
<
=={{header|Smalltalk}}==
<
"Multiline comments are also supported.
Comments are saved as metadata along with the source to a method.
A comment just after a method signature is often given to explain the
usage of the method. The class browser may display such comments
specially."</
=={{header|smart BASIC}}==
<syntaxhighlight lang="text">'Single line comments are preceded by a single quote or the command REM
PRINT "Hello" 'Single line comments may follow code
Line 2,814 ⟶ 3,101:
/* A comment can also follow another comment */ 'Like this
Some programmers like to do this to allow for /* Procedural comments */ followed by 'Programmer's notes.</
=={{header|SNOBOL4}}==
<syntaxhighlight lang="snobol4">
* An asterisk in column 1 is the standard Snobol comment
* mechanism, marking the entire line as a comment. There
Line 2,837 ⟶ 3,124:
END
Any text after the required END label is ignored.</
=={{header|SNUSP}}==
Line 2,848 ⟶ 3,135:
=={{header|SPL}}==
<
''This is
multiline comment''</
=={{header|SQL}}==
Line 2,857 ⟶ 3,144:
The comment appears on the same line as the statement:
<
or before:
<
SELECT * FROM mytable </
or after:
<
-- Selects all columns and rows</
=={{header|SQL PL}}==
Line 2,869 ⟶ 3,156:
Single line comment:
<
--This is a single line comment.
</syntaxhighlight>
Multiline comment:
<
/* This is
a multiline
comment */
</syntaxhighlight>
Another way to do multiline comments
<
(= This is
a multiline
comment =)
</syntaxhighlight>
End of line comment:
<
declare myvar number; --This is an end of line comment.
</syntaxhighlight>
Comments work the same as in [[SQL]].
=={{header|Squirrel}}==
<
#this is also a single line comment
Line 2,904 ⟶ 3,191:
/*
this is a multi-line comment
*/</
=={{header|SSEM}}==
The SSEM can only be programmed in pure binary, by setting front panel switches: the concepts of "text" and "source file" (both mentioned in the specification) are therefore not directly applicable to it. If binary numbers have any mnemonic or explanatory value for you, however, there is a way of including information in your program that the computer will ignore. This is a direct result of the machine's rather poor code density. Each 32-bit instruction word consists of (a) a five-bit address field giving the operand, (b) eight unused bits, (c) a three-bit instruction field giving the operation to be performed, and (d) sixteen more unused bits. If the instruction field is set to <tt>011 Test</tt> or <tt>111 Stop</tt>, even the address field is unused. In the case of a <tt>Sub.</tt> instruction, finally, the leftmost bit of the instruction field is disregarded: <tt>001</tt> and <tt>101</tt> both mean "subtract". We therefore have at least 24 and sometimes 25 or 29 bits in each instruction that we can, if we like, use for comments. The word
<syntaxhighlight lang
will be understood by the machine as <tt>Add 20 to CI</tt>, a normal instruction. But it also fits four comment characters into the unused bits, employing a simple five-bit encoding where <tt>A</tt>=0 and <tt>Z</tt>=25. The instruction breaks down as follows:
Line 2,933 ⟶ 3,220:
=={{header|Standard ML}}==
<
(* containing nested comment *)
*)</
=={{header|Stata}}==
<
// Line comment until the end of the line
Line 2,944 ⟶ 3,231:
/* Multiline comment
*/</
=={{header|SuperTalk}}==
<syntaxhighlight lang="supertalk">-- This is a comment</syntaxhighlight>
=={{header|Swift}}==
<
/* This a block comment
/* containing nested comment */
Line 2,956 ⟶ 3,246:
/**
This is a documentation block comment
*/</
=={{header|Symsyn}}==
<syntaxhighlight lang="symsyn">
| This is a comment
</syntaxhighlight>
=={{header|Tcl}}==
Line 2,967 ⟶ 3,257:
Tcl follows the usual scripting language rules: a comment starts at a "#" symbol, which can be placed after a command if that is terminated by a semicolon:
<
set var1 $value1
set var2 $value2 ; # comment that follows a line of code</
The reason for the need for a semi-colon on a trailing comment is this:
Line 2,977 ⟶ 3,267:
The "#" symbol has no special meaning if it is not where a command would appear -- it's just data. (Syntax highlighters often get this wrong.)
<
lappend aList # bar
puts $aList ;# ==> prints "foo # bar"
puts [llength $aList] ;# ==> 3</
TCL has no native multi-line comment format. However, in most circumstances, a multi-line comment can be faked by wrapping it within a block that will never be executed:
<
Comments...
}</
=={{header|Tern}}==
Line 2,995 ⟶ 3,285:
One common approach is to put the comment in a string which is not stored anywhere:
<
However this will change the Ans variable.
This approach, while messier, does not affect the Ans variable:
<
:THIS IS A COMMENT</
=={{header|TI-89 BASIC}}==
<
=={{header|Tiny BASIC}}==
<syntaxhighlight lang="tiny basic">
10 REM this is a comment
20
Line 3,014 ⟶ 3,304:
40 REM from above you can see that line numbers with no statement
50 REM and blank lines also are ignored
</syntaxhighlight>
=={{header|Toka}}==
Line 3,021 ⟶ 3,311:
a line, the shebang is normally used:
<
The shebang comments can not be used inside of functions.
Line 3,027 ⟶ 3,317:
In addition, Toka also accepts parenthetical comments. These are enclosed in parenthesis, and are often used for stack comments or comments inside functions.
<
... ] is myword</
In addition, parenthetical comments can span multiple lines.
<
simple, multi-line
comment )</
Since comments are provided by actual functions, the comment function must be whitespace delimited, just as with all other functions in Toka.
Line 3,040 ⟶ 3,330:
A final way to include text in a file is to mark a false ending with '''end.'''
<
end.
Nothing following the end. will be evaluated by Toka.</
=={{header|TorqueScript}}==
<syntaxhighlight lang
=={{header|TPP}}==
<
=={{header|Transd}}==
<
/* This is a single line block comment.*/
/* This is
a multi-line
block comment.*/
</syntaxhighlight>
=={{header|TUSCRIPT}}==
<
$$ MODE TUSCRIPT
- This is a comment
</syntaxhighlight>
=={{header|TXR}}==
<
@; new-style comment to end of line
@(bind a ; comment within expression
"foo")</
=={{header|UNIX Shell}}==
Line 3,078 ⟶ 3,368:
{{works with|Korn Shell}}
<
# A leading hash symbol begins a comment.
echo "Hello" # Comments can appear after a statement.
Line 3,084 ⟶ 3,374:
# The hash symbol must be at the beginning of a word.
echo This_Is#Not_A_Comment
#Comment</
==={{header|C Shell}}===
<
# C Shell has a similar comment syntax, but only allows comments in a
# script file, not in terminal input.
echo Hello#With C Shell, the hash can also be in the middle of a word.</
==={{header|es}}===
<
echo Hello#With es, the hash can also be in the middle of a word.</
=={{header|Unlambda}}==
Line 3,117 ⟶ 3,407:
=={{header|Ursa}}==
Comments in Ursa must be on a single line, and are denoted by a #
<
# this is another comment
</syntaxhighlight>
=={{header|Ursala}}==
There are lots of ways to have comments in Ursala.
Here are the conventional ones.
<
# this is a\
Line 3,140 ⟶ 3,430:
###
The whole rest of the file after three hashes
is a comment.</
=== Commenting out code ===
Line 3,147 ⟶ 3,437:
An individual item of a syntactically correct list or aggregate is commented
out like this.
<
The 2 is ignored but 1 and 3 aren't. This also works with
nested aggregates and multiple lines.
<syntaxhighlight lang="ursala">a =
<
Line 3,159 ⟶ 3,449:
'not',
'to',
## 'be'></
A syntactically correct declaration can be commented out like this.
<
##
Line 3,167 ⟶ 3,457:
bar = 2
baz = 3</
As far as the compiler is concerned, bar is not defined, but foo and baz are.
It wouldn't matter if bar took multiple lines.
Line 3,175 ⟶ 3,465:
to embed comments in executable files and libraries it generates without
affecting their semantics.
<
I document the source text but will also be embedded in
the output library or executable file.]-
#comment gpl'3'</
The latter comment puts the standard GPL license notification in the output file.
Line 3,186 ⟶ 3,476:
A function f annotated with a crash dump wrapper expressed like this
during debugging
<syntaxhighlight lang
is equivalent to just f when changed to this in the production code.
<syntaxhighlight lang
=== Comments as hooks ===
Line 3,194 ⟶ 3,484:
Compiling with the --depend command line option makes the compiler only scan for the #depend'ed
expressions and send them to standard output.
<
otherwise,
ignored}</
This way, scripts and source management tools can have information passed to them from
the programmer by running the compiler instead of re-implementing their own parsers.
Line 3,202 ⟶ 3,492:
=={{header|VBA}}==
A comment starts with a quote (') and it ends at end of line
<
</syntaxhighlight>
=={{header|VBScript}}==
A comment starts with a quote (') and it ends at end of line
<
</syntaxhighlight>
=={{header|Verbexx}}==
<
//////////////////////////////////////////////////////////////////////////////////////////////
//
Line 3,304 ⟶ 3,594:
| |
\=================================================================================================/
</syntaxhighlight>
=={{header|Verilog}}==
<
/*
Line 3,313 ⟶ 3,603:
line
comment.
*/</
=={{header|VHDL}}==
<
=={{header|Vim Script}}==
Line 3,323 ⟶ 3,613:
In most cases, " will also work after a command (i.e. the rest of the line will be ignored). But some commands like <code>echo</code> treat the whole line as their argument and thus will raise an error (''Missing quote'').
<
echo "foo" " Not a comment but an argument that misses the closing quote</
=={{header|Visual Basic}}==
Line 3,330 ⟶ 3,620:
In addition to the methods mentioned in [[#BASIC|BASIC]] above, it is also somewhat common to effectively comment out code by including the unwanted code inside an <code>#If 0 ... #End If</code> block. (This works because 0 evaluates to False in VB.) Note, however, that the IDE will complain about actual comments inside an <code>#If 0</code> block unless it's also commented normally (i.e., using <code>Rem</code> or <code>'</code>).
<
Rem comment
#If 0
Line 3,336 ⟶ 3,626:
IDE won't. Note the somewhat odd formatting seen here; the IDE will likely
just mark the entire line(s) as errors.
#End If</
=={{header|Visual Basic .NET}}==
Visual Basic .NET uses the "'" symbol or "REM" to mark it's comments. After placing a "'", or "REM", everything in that line will be ignored.
<
REM This is also a comment
Dim comment as string ' You can also append comments to statements
Dim comment2 as string REM You can append comments to statements</
=={{header|Visual Objects}}==
<
// This is a comment
/* This is a comment */
Line 3,354 ⟶ 3,644:
NOTE This is a commen
</syntaxhighlight>
=={{header|V (Vlang)}}==
<pre>
// This is a single line comment.
Line 3,367 ⟶ 3,657:
=={{header|Vorpal}}==
<syntaxhighlight lang
=={{header|Wart}}==
<syntaxhighlight lang
=={{header|Wren}}==
<
/* This is a single line block comment.*/
/* This is
a multi-line
block comment.*/
/* This is/* a nested */block comment.*/</
=={{header|X10}}==
Line 3,386 ⟶ 3,675:
All text from the ASCII characters “//” to the end of line is considered a comment and is ignored.
<
/*
This comment spans
multiple lines
*/</
=={{header|XLISP}}==
<syntaxhighlight lang
=={{header|Xojo}}==
<syntaxhighlight lang="vb">
// Comments are denoted by a preceding double slash or or single quote
' and continue to the end of the line. There are no multi-line comment blocks
Dim foo As Integer // Comments can also occupy the ends of code lines</
=={{header|XPL0}}==
Line 3,407 ⟶ 3,696:
always terminates a comment. Consequently there is no multi-line
comment. For example:
<
Since backslashes toggle comments on and off, it could be inconvenient to
comment out a line of code that contains a comment. For example, two
additional backslashes could be used to comment out this line, as shown here:
<
\Text(0, "Hello World"); \\comment</
However, two backslashes together comment out everything to the end of
the line regardless of any backslashes the line might contain. So the
first example could be commented out like this:
<
Conditional compilation can be used to effectively comment out multiple
lines of code. For example:
<
Text(0, "Hello World"); \comment
CrLf(0);
cond true;</
=={{header|XQuery}}==
<
=={{header|XSLT}}==
<
=={{header|XUL}}==
<
=={{header|Yacas}}==
Yacas supports C++ style comments:
<
/*
This comment spans
multiple lines
*/</
=={{header|Z80 Assembly}}==
Note: syntax depends on the assembler software but use of a semicolon is fairly standard. VASM and WinAPE use the semicolon.
<
=={{header|
<
/// This is a documentation comment in Zig (for the following line)</
=={{header|zkl}}==
<
x=2; # ala scripts
/* ala C, these comments are parsed (also ala C) */
Line 3,462 ⟶ 3,751:
#<<<#
"here" comment, unparsed
#<<<#</
=={{header|Zoea}}==
<syntaxhighlight lang="zoea">
program comments # this program does nothing
Line 3,475 ⟶ 3,764:
comments
*/
</syntaxhighlight>
=={{header|Zoea Visual}}==
Line 3,481 ⟶ 3,770:
=={{header|zonnon}}==
<
(* this is a comment *)
(*
Line 3,488 ⟶ 3,777:
(* with a nested comment *)
*)
</syntaxhighlight>
=={{omit from|Computer/zero Assembly}}==
|