Kommentar (datorprogrammering) - Comment (computer programming)

För kommentarer i Wikipedia -markering, se Hjälp: Wiki -markering#Teckenformatering och WP: COMMENT .
Image
En illustration av Java -källkod med prologkommentarer indikerade i rött och inline -kommentarer i grönt . Programkoden är blå .

I datorprogrammering är en kommentar en programmerarläsbar förklaring eller kommentar i källkoden för ett datorprogram . De läggs till i syfte att göra källkoden lättare för människor att förstå och ignoreras i allmänhet av kompilatorer och tolkar . Den syntax kommentarer i olika programspråk varierar avsevärt.

Kommentarer bearbetas ibland också på olika sätt för att generera dokumentation utanför själva källkoden av dokumentationsgeneratorer , eller används för integration med källkodshanteringssystem och andra typer av externa programmeringsverktyg .

Flexibiliteten från kommentarer möjliggör en stor grad av variation, men formella konventioner för deras användning är vanligtvis en del av programmeringsstilguider.

Översikt

Kommentarer formateras generellt som antingen blockkommentarer (kallas även prologkommentarer eller strömkommentarer ) eller radkommentarer (kallas även inline -kommentarer ).

Blockkommentarer avgränsar en region med källkod som kan sträcka sig över flera rader eller en del av en enda rad. Denna region specificeras med en start avgränsare och ett slut avgränsare. Vissa programmeringsspråk (t.ex. MATLAB ) gör att blockkommentarer kan rekursivt kapslas inuti varandra, men andra (t.ex. Java ) gör det inte.

Radkommentarer börjar antingen med en kommentaravgränsare och fortsätter till slutet av raden, eller i vissa fall börjar du med en specifik kolumn (teckenradförskjutning) i källkoden och fortsätter till slutet av raden.

Vissa programmeringsspråk använder både block- och radkommentarer med olika kommentarsavgränsare. Till exempel har C ++ blockkommentarer avgränsade av /*och */som kan sträcka sig över flera rader och radkommentarer avgränsade av //. Andra språk stöder bara en typ av kommentarer. Till exempel, Ada kommentarer är linje kommentarer: de börjar med --och fortsätter till slutet av raden.

Användningsområden

Hur man bäst använder kommentarer är föremål för tvist; olika kommentatorer har erbjudit varierade och ibland motsatta synpunkter. Det finns många olika sätt att skriva kommentarer och många kommentatorer ger motstridiga råd.

Planera och granska

Kommentarer kan användas som en form av pseudokod för att beskriva avsikten innan du skriver den faktiska koden. I det här fallet bör det förklara logiken bakom koden snarare än själva koden. . 

/* loop backwards through all elements returned by the server 
(they should be processed chronologically)*/
for (i = (numElementsReturned - 1); i >= 0; i--) {
    /* process each element's data */
    updatePattern(i, returnedElements[i]);
}

Om denna typ av kommentarer lämnas in förenklar det granskningsprocessen genom att tillåta en direkt jämförelse av koden med de avsedda resultaten. En vanlig logisk misstag är att koden som är lätt att förstå gör vad den ska göra.

Kodbeskrivning

Kommentarer kan användas för att sammanfatta kod eller för att förklara programmerarens avsikt. Enligt denna tankegång anses återställning av koden på vanlig engelska vara överflödig; behovet av att omförklara koden kan vara ett tecken på att den är för komplex och bör skrivas om, eller att namnet är dåligt.

"Dokumentera inte dålig kod - skriv om den."
"Bra kommentarer upprepar inte koden eller förklarar den. De förtydligar dess avsikt. Kommentarer bör förklara, på en högre abstraktionsnivå än koden, vad du försöker göra."

Kommentarer kan också användas för att förklara varför ett kodblock inte verkar passa konventioner eller bästa praxis. Detta gäller särskilt projekt som inbegriper mycket liten utvecklingstid, eller för felkorrigering. Till exempel: 

' Second variable dim because of server errors produced when reuse form data. No
' documentation available on server behavior issue, so just coding around it.
vtx = server.mappath("local settings")

Algoritmisk beskrivning

Ibland innehåller källkoden en ny eller anmärkningsvärd lösning på ett specifikt problem. I sådana fall kan kommentarer innehålla en förklaring av metodiken. Sådana förklaringar kan inkludera diagram och formella matematiska bevis. Detta kan utgöra en förklaring av koden, snarare än ett förtydligande av dess avsikt; men andra som har till uppgift att upprätthålla kodbasen kan tycka att en sådan förklaring är avgörande. Detta kan särskilt vara sant när det gäller högspecialiserade problemdomäner; eller sällan använda optimeringar, konstruktioner eller funktionsanrop.

Till exempel kan en programmerare lägga till en kommentar för att förklara varför en insättningssort valdes i stället för en kvicksort , eftersom den förra i teorin är långsammare än den senare. Detta kan skrivas enligt följande: 

 list = [f (b), f (b), f (c), f (d), f (a), ...];
 // Need a stable sort. Besides, the performance really does not matter.
 insertion_sort (list);

Resurs inkludering

Logotyper , diagram och flödesscheman som består av ASCII -konstkonstruktioner kan infogas i källkoden formaterad som en kommentar. Vidare kan upphovsrättsmeddelanden bäddas in i källkoden som kommentarer. Binär data kan också kodas i kommentarer genom en process som kallas binär-till-text-kodning , även om sådan praxis är ovanlig och vanligtvis förflyttas till externa resursfiler.

Följande kodfragment är ett enkelt ASCII -diagram som visar processflödet för ett systemadministrationsskript som finns i en Windows Script -fil som körs under Windows Script Host . Även om en sektion som markerar koden visas som en kommentar, visas själva diagrammet faktiskt i en XML CDATA -sektion, som tekniskt anses skiljas från kommentarer, men kan tjäna liknande ändamål. 

<!-- begin: wsf_resource_nodes -->
<resource id="ProcessDiagram000">
<![CDATA[
 HostApp (Main_process)
    |
    V
script.wsf (app_cmd) --> ClientApp (async_run, batch_process)
                |
                |
                V
         mru.ini (mru_history)  
]]>
</resource>

Även om detta identiska diagram lätt kunde ha inkluderats som en kommentar, illustrerar exemplet en instans där en programmerare kan välja att inte använda kommentarer som ett sätt att inkludera resurser i källkoden.

Metadata

Huvudartikel: Metadata

Kommentarer i ett datorprogram lagrar ofta metadata om en programfil.

I synnerhet skriver många programvaruansvariga riktlinjer för inlämning i kommentarer för att hjälpa människor som läser programmets källkod att skicka de förbättringar de gör tillbaka till underhållaren.

Andra metadata inkluderar: namnet på skaparen av den ursprungliga versionen av programfilen och datumet då den första versionen skapades, namnet på den nuvarande underhållaren av programmet, namnen på andra personer som har redigerat programfilen hittills , URL: en för dokumentation om hur du använder programmet, namnet på programvarulicensen för denna programfil, etc.

När en algoritm i någon del av programmet är baserad på en beskrivning i en bok eller annan referens, kan kommentarer användas för att ange sidnummer och titel på boken eller begäran om kommentarer eller annan referens.

Felsökning

En vanlig utvecklarpraxis är att kommentera ett kodavsnitt, vilket innebär att man lägger till kommentarsyntax som gör att kodblocket blir en kommentar, så att det inte körs i det slutliga programmet. Detta kan göras för att utesluta vissa kodbitar från det slutliga programmet, eller (mer vanligt) kan det användas för att hitta källan till ett fel. Genom att systematiskt kommentera och köra delar av programmet kan källan till ett fel bestämmas så att det kan korrigeras.

Ett exempel på att kommentera koden för uteslutningsändamål är nedan:

Ovanstående kodfragment tyder på att programmeraren av någon anledning valde att inaktivera felsökningsalternativet.

Många IDE: er gör det möjligt att snabbt lägga till eller ta bort sådana kommentarer med enstaka menyalternativ eller tangentkombinationer. Programmeraren behöver bara markera den del av texten de vill (av) kommentera och välja lämpligt alternativ.

Automatisk dokumentationsgenerering

Huvudartikel: Dokumentationsgenerator

Programmeringsverktyg lagrar ibland dokumentation och metadata i kommentarer. Dessa kan inkludera infogningspositioner för automatisk inkludering av rubrikfiler, kommandon för att ställa in filens syntaxmarkeringsläge eller filens revisionsnummer . Dessa funktionskontrollkommentarer kallas också vanligtvis som kommentarer . Att hålla dokumentation inom källkodskommentarer anses vara ett sätt att förenkla dokumentationsprocessen, samt öka chansen att dokumentationen kommer att hållas uppdaterad med ändringar i koden.

Exempel på dokumentationsgeneratorer inkluderar programmen Javadoc för användning med Java , Ddoc för D , Doxygen för C , C ++ , Java, IDL , Visual Expert för PL/SQL , Transact-SQL , PowerBuilder och PHPDoc för PHP . Former för docstring stöds av Python , Lisp , Elixir och Clojure .

C# , F# och Visual Basic .NET implementerar en liknande funktion som kallas "XML -kommentarer" som läses av IntelliSense från den sammanställda .NET -enheten.

Syntaxförlängning

Ibland ändras syntaxelement som ursprungligen var avsedda att vara kommentarer för att överföra ytterligare information till ett program, till exempel " villkorade kommentarer ". Sådana "heta kommentarer" kan vara den enda praktiska lösningen som bibehåller bakåtkompatibilitet, men betraktas allmänt som en kludge .

Direktivet använder

Det finns fall där de normala kommentar tecken är adjungerad att skapa en speciell direktiv för en redaktör eller tolk.

Två exempel på hur man leder en tolk är:

  • Unix " shebang " - #!- används på första raden i ett manus för att peka på tolkaren som ska användas.
  • "Magiska kommentarer" som identifierar kodningen som en källfil använder, t.ex. Pythons PEP 263.

Skriptet nedan för ett Unix-liknande system visar båda dessa användningsområden: 

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-
print("Testing")

Något liknande är användningen av kommentarer i C för att meddela en kompilator att ett standard "genomslag" i ett ärende har gjorts medvetet: 

switch (command) {
    case CMD_SHOW_HELP_AND_EXIT:
      do_show_help();
      /* Fall thru */
    case CMD_EXIT:
      do_exit();
      break;
    case CMD_OTHER:
      do_other();
      break;
    /* ... etc. ... */
  }

Att infoga en sådan /* Fall thru */kommentar för mänskliga läsare var redan en vanlig konvention, men 2017 började gcc -kompilatorn leta efter dessa (eller andra indikationer på avsiktlig avsikt), och, om den inte hittades, avger: "varning: detta uttalande kan falla igenom" .

Många redaktörer och IDE kommer att läsa specialformaterade kommentarer. Till exempel "modell" -funktionen hos Vim ; vilket skulle förändra hanteringen av flikar medan du redigerar en källa med denna kommentar som finns nära toppen av filen: 

# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4

Stressavlastning

Ibland kommer programmerare att lägga till kommentarer som ett sätt att lindra stress genom att kommentera utvecklingsverktyg, konkurrenter, arbetsgivare, arbetsförhållanden eller kvaliteten på själva koden. Förekomsten av detta fenomen kan lätt ses från onlineresurser som spårar svordomar i källkoden.

Normativa åsikter

Det finns olika normativa åsikter och långvariga åsikter om korrekt användning av kommentarer i källkoden. Några av dessa är informella och baserade på personlig preferens, medan andra publiceras eller utfärdas som formella riktlinjer för ett visst samhälle.

Behöver kommentarer

Experter har olika synpunkter på om och när kommentarer är lämpliga i källkoden. Vissa hävdar att källkoden ska skrivas med få kommentarer, utifrån att källkoden ska vara självförklarande eller självdokumenterande . Andra föreslår att koden bör kommenteras i stor utsträckning (det är inte ovanligt att över 50% av de icke- vita mellanslagstecknen i källkoden finns i kommentarerna).

Mellan dessa åsikter finns påståendet att kommentarer varken är fördelaktiga eller skadliga i sig själva, och det viktiga är att de är korrekta och hålls synkroniserade med källkoden och utelämnas om de är överflödiga, överdrivna, svåra att underhålla eller på annat sätt inte är till hjälp.

Kommentarer används ibland för att dokumentera kontrakt i utformningen genom kontraktsmetod för programmering.

Detaljnivå

Beroende på den avsedda målgruppen för koden och andra överväganden kan detaljnivån och beskrivningen variera avsevärt.

Till exempel skulle följande Java -kommentar vara lämplig i en inledande text som är utformad för att lära in programmering: 

String s = "Wikipedia"; /* Assigns the value "Wikipedia" to the variable s. */

Denna detaljnivå skulle dock inte vara lämplig i samband med produktionskod eller andra situationer som involverar erfarna utvecklare. Sådana rudimentära beskrivningar är oförenliga med riktlinjen: "Bra kommentarer ... förtydligar avsikten." Vidare, för professionella kodningsmiljöer, är detaljnivån vanligtvis väldefinierad för att uppfylla ett specifikt prestationskrav som definieras av affärsverksamhet.

Stilar

Det finns många stilistiska alternativ tillgängliga när man överväger hur kommentarer ska visas i källkoden. För större projekt som involverar ett team av utvecklare, antingen kommenteras stilar antingen innan ett projekt startar, eller utvecklas i enlighet med konvention eller behov när ett projekt växer. Vanligtvis föredrar programmerare stilar som är konsekventa, icke-obstruktiva, enkla att ändra och svåra att bryta.

Blockera kommentar

Följande kodfragment i C visar bara ett litet exempel på hur kommentarer kan variera stilistiskt, samtidigt som de förmedlar samma grundläggande information: 

/*
     This is the comment body.
     Variation One.
*/

/***************************\
*                           *
* This is the comment body. *
* Variation Two.            *
*                           *
\***************************/

Faktorer som personlig preferens, flexibilitet i programmeringsverktyg och andra överväganden tenderar att påverka de stilistiska varianterna som används i källkoden. Till exempel kan variant två missgynnas bland programmerare som inte har källkodredigerare som kan automatisera anpassning och visuellt utseende av text i kommentarer.

Programvarukonsult och teknikkommentator Allen Holub är en expert som förespråkar att de vänstra kanterna på kommentarer ska anpassas: 

 /* This is the style recommended by Holub for C and C++.
  * It is demonstrated in ''Enough Rope'', in rule 29.
  */

 /* This is another way to do it, also in C.
 ** It is easier to do in editors that do not automatically indent the second
 ** through last lines of the comment one space from the first.
 ** It is also used in Holub's book, in rule 31.
 */

Användningen av/ * och */som avgränsare för blockkommentarer ärvdes från PL/I till programmeringsspråket B, den närmaste föregångaren till programmeringsspråket C.

Radkommentarer

Linjekommentarer använder vanligtvis en godtycklig avgränsare eller sekvens av tokens för att indikera början på en kommentar, och ett nyradstecken för att indikera slutet på en kommentar.

I det här exemplet ignoreras all text från ASCII -tecknen // till slutet av raden. 

// -------------------------
// This is the comment body.
// -------------------------

Ofta måste en sådan kommentar börja längst till vänster och sträcka sig till hela raden. Men på många språk, är det också möjligt att sätta en kommentar inline med en kommandorad, att lägga till en kommentar till det - som i detta Perl exempel: 

print $s . "\n";     # Add a newline character after printing

Om ett språk tillåter både radkommentarer och blockkommentarer kan programmeringsteam besluta om en konvention om att använda dem annorlunda: t.ex. radkommentarer endast för mindre kommentarer och blockera kommentarer för att beskriva abstraktioner på högre nivå.

Taggar

Programmerare kan använda informella taggar i kommentarer för att hjälpa till med indexering av vanliga problem. De kan sedan kunna sökas med vanliga programmeringsverktyg, såsom Unix grep verktyget eller syntax-markerad inom textredigerare . Dessa kallas ibland "kodtaggar" eller "tokens".

Sådana taggar skiljer sig mycket åt, men kan innehålla:

  • BUG - en känd bugg som bör korrigeras.
  • FIXME - bör korrigeras.
  • HACK - en lösning.
  • TODO - något att göra.
  • OUTFÖRT - en omvändning eller "roll back" av tidigare kod.
  • XXX - varna andra programmerare för problematisk eller vilseledande kod

Exempel

Jämförelse

Huvudartikel: Jämförelse av programmeringsspråk (syntax) § Kommentarer

Typografiska konventioner för att specificera kommentarer varierar mycket. Vidare ger enskilda programmeringsspråk ibland unika varianter. För en detaljerad granskning, vänligen läs artikeln om jämförelse av programmeringsspråk .

Ada

De Ada programmeringsspråk användningsområden '-' för att indikera en kommentar fram till slutet av raden.

Till exempel: 

  -- the air traffic controller task takes requests for takeoff and landing
   task type Controller (My_Runway: Runway_Access) is
      -- task entries for synchronous message passing
      entry Request_Takeoff (ID: in Airplane_ID; Takeoff: out Runway_Access);
      entry Request_Approach(ID: in Airplane_ID; Approach: out Runway_Access);
   end Controller;

APL

APL använder för ⍝att indikera en kommentar fram till slutet av raden.

Till exempel: 

⍝ Now add the numbers:
c←a+b ⍝ addition

I dialekter som har ⊣("vänster") och ⊢("höger") primitiv kan kommentarer ofta vara inuti eller separata uttalanden, i form av ignorerade strängar: 

d←2×c ⊣'where'⊢ c←a+ 'bound'⊢ b

AppleScript

Det här avsnittet i AppleScript -koden visar de två stilar av kommentarer som används på det språket. 

(*
This program displays a greeting.
*)
on greet(myGreeting)
     display dialog myGreeting & " world!"
end greet

-- Show the greeting
greet("Hello")

GRUNDLÄGGANDE

I detta klassiska tidiga BASIC -kodfragment används nyckelordet REM ( "Remark" ) för att lägga till kommentarer. 

10 REM This BASIC program shows the use of the PRINT and GOTO Statements.
15 REM It fills the screen with the phrase "HELLO"
20 PRINT "HELLO"
30 GOTO 20

I senare Microsoft BASIC, inklusive Quick Basic , Q Basic , Visual Basic , Visual Basic .NET och VB Script ; och i ättlingar som FreeBASIC och Gambas behandlas varje text på en rad efter en '(apostrof) karaktär också som en kommentar.

Ett exempel i Visual Basic .NET: 

Public Class Form1
    Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
        ' The following code is executed when the user
        ' clicks the button in the program's window.
        rem comments still exist.

        MessageBox.Show("Hello, World") 'Show a pop-up window with a greeting
    End Sub
End Class

C

Detta C -kodfragment demonstrerar användningen av en prologkommentar eller "blockkommentar" för att beskriva syftet med ett villkorligt uttalande . Kommentaren förklarar viktiga termer och begrepp och innehåller en kort signatur av programmeraren som skapade koden. 

 /*
  * Check if we are over our maximum process limit, but be sure to
  * exclude root. This is needed to make it possible for login and
  * friends to set the per-user process limit to something lower
  * than the amount of processes root is running. -- Rik
  */
 if (atomic_read(&p->user->processes) >= p->rlim[RLIMIT_NPROC].rlim_cur
     && !capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RESOURCE))
     goto bad_fork_free;

Sedan C99 har det också varit möjligt att använda // syntaxen från C ++, vilket indikerar en kommentar med en rad.

Cisco IOS- och IOS-XE-konfiguration

Den utropstecken ( ! ) Kan användas för att kommentarer markera i en Cisco-router konfiguration läge, men sådana kommentarer inte sparas icke-flyktigt minne (som innehåller startup-config), och inte heller de visas av "show run" -kommandot .

Det är möjligt att infoga läsbart innehåll som faktiskt är en del av konfigurationen och kan sparas i NVRAM- startkonfigurationen via:

  • Den "beskrivning" kommandot, som används för att lägga till en beskrivning till konfigurationen av ett gränssnitt eller en BGP granne
  • Parametern "namn", för att lägga till en anmärkning till en statisk rutt
  • Kommandot "anmärkning" i åtkomstlistor
! Paste the text below to reroute traffic manually
config t
int gi0/2
no shut
ip route 0.0.0.0 0.0.0.0 gi0/2 name ISP2
no ip route 0.0.0.0 0.0.0.0 gi0/1 name ISP1
int gi0/1
shut
exit

Kall fusion

ColdFusion använder kommentarer som liknar HTML -kommentarer , men i stället för två streck använder den tre. Dessa kommentarer fångas upp av ColdFusion -motorn och skrivs inte ut i webbläsaren. 

 <!--- This prints "Hello World" to the browser. --->
 <cfoutput>
   Hello World<br />
 </cfoutput>

Fortran IV

Detta Fortran IV- kodfragment visar hur kommentarer används på det språket, vilket är mycket kolumnorienterat. En bokstav "C" i kolumn 1 gör att hela raden behandlas som en kommentar. 

C
C Lines that begin with 'C' (in the first or 'comment' column) are comments
C
      WRITE (6,610)
  610 FORMAT(12H HELLO WORLD)
      END

Observera att kolumnerna i en rad annars behandlas som fyra fält: 1 till 5 är etikettfältet, 6 gör att raden tas som en fortsättning på det föregående påståendet; och deklarationer och uttalanden går i 7 till 72.

Fortran 90

Detta Fortran -kodfragment demonstrerar hur kommentarer används på det språket, där kommentarerna själva beskriver de grundläggande formateringsreglerna. 

!* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
!* All characters after an exclamation mark are considered as comments *
!* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
program comment_test
    print '(A)', 'Hello world' ! Fortran 90 introduced the option for inline comments.
end program

Haskell

Radkommentarer i Haskell börjar med '-' (två bindestreck) till slutet av raden, och flera radkommentarer börjar med '{-' och slutar med '-}'. 

{- this is a comment
on more lines -}
-- and this is a comment on one line
putStrLn "Wikipedia"  -- this is another comment

Haskell tillhandahåller också en läskunnig programmeringsmetod för att kommentera känd som "Bird Style". I detta tolkas alla rader som börjar med> som kod, allt annat anses vara en kommentar. Ett ytterligare krav är att du alltid lämnar en tom rad före och efter kodblocket: 

In Bird-style you have to leave a blank before the code.

> fact :: Integer -> Integer
> fact 0 = 1
> fact (n+1) = (n+1) * fact n

And you have to leave a blank line after the code as well.

Läskunnig programmering kan också göras i Haskell med LaTeX . Kodmiljön kan användas istället för Richard Birds stil: I LaTeX -stil motsvarar detta exemplet ovan, kodmiljön kan definieras i LaTeX -ingressen. Här är en enkel definition: 

\usepackage{verbatim}
\newenvironment{code}{\verbatim}{\endverbatim}

senare i 

% the LaTeX source file
The \verb|fact n| function call computes $n!$ if $n\ge 0$, here is a definition:\\
\begin{code}
fact :: Integer -> Integer
fact 0 = 1
fact (n+1) = (n+1) * fact n
\end{code}
Here more explanation using \LaTeX{} markup

Java

Detta Java -kodfragment visar en blockkommentar som används för att beskriva setToolTipTextmetoden. Formateringen överensstämmer med Sun Microsystems Javadoc -standarder. Kommentaren är utformad för att läsas av Javadoc -processorn. 

/**
 * This is a block comment in Java.
 * The setToolTipText method registers the text to display in a tool tip.
 * The text is displayed when the cursor lingers over the component.
 *
 * @param text  The string to be displayed.  If 'text' is null,
 *              the tool tip is turned off for this component.
 */
public void setToolTipText(String text) {
    // This is an inline comment in Java. TODO: Write code for this method.
}

JavaScript

JavaScript använder // för att föregå kommentarer och / * * / för kommentarer med flera rader. 

// A single line JavaScript comment
var iNum = 100;
var iTwo = 2; // A comment at the end of line
/*
multi-line
JavaScript comment
*/

Lua

Den Lua programmeringsspråk använder dubbla bindestreck, --för enda rad kommentarer i ett liknande sätt som Ada , Eiffel , Haskell , SQL och VHDL språk. Lua har också blockkommentarer, som börjar med --[[och löper fram till ett avslutande]]

Till exempel: 

--[[A multi-line
long comment
]]
print(20)   -- print the result

En vanlig teknik för att kommentera en kodbit är att bifoga koden mellan --[[och --]]enligt nedan: 

--[[
print(10)
--]]
-- no action (commented out)

I det här fallet är det möjligt att återaktivera koden genom att lägga till ett enda bindestreck på den första raden: 

---[[
print(10)
--]]
--> 10

I det första exemplet --[[börjar på den första raden en lång kommentar, och de två bindestreckarna i den sista raden är fortfarande inne i den kommentaren. I det andra exemplet ---[[startar sekvensen en vanlig kommentar med en rad, så att den första och den sista raden blir oberoende kommentarer. I det här fallet printär det yttre kommentarer. I det här fallet blir den sista raden en oberoende kommentar, som den börjar med --.

Långa kommentarer i Lua kan vara mer komplexa än dessa, som du kan läsa i avsnittet "Långa strängar" jfr Programmering i Lua .

MATLAB

I MATLAB : s programmeringsspråk anger "%" -tecknet en kommentar med en rad. Flerradskommentarer är också tillgängliga via %{och %} parenteser och kan kapslas, t.ex. 

% These are the derivatives for each term
d = [0 -1 0];

%{
  %{
    (Example of a nested comment, indentation is for cosmetics (and ignored).)
  %}
  We form the sequence, following the Taylor formula.
  Note that we're operating on a vector.
%}
seq = d .* (x - c).^n ./(factorial(n))

% We add-up to get the Taylor approximation
approx = sum(seq)

Nim

Nim använder tecknet "#" för inline kommentarer. Blockeringskommentarer med flera rader öppnas med "#[" och stängs med "]#". Blockerade kommentarer med flera rader kan häckas.

Nim har också dokumentationskommentarer som använder blandade Markdown- och ReStructuredText -markeringar. Kommentarerna för den inbyggda dokumentationen använder "##" och flerradiga blockdokumentationskommentarer öppnas med "## [" och stängs med "] ##". Kompilatorn kan generera HTML- , LaTeX- och JSON -dokumentation från dokumentationskommentarer. Dokumentationskommentarer är en del av det abstrakta syntaxträdet och kan extraheras med hjälp av makron. 

## Documentation of the module *ReSTructuredText* and **MarkDown**
# This is a comment, but it is not a documentation comment.

type Kitten = object  ## Documentation of type
  age: int  ## Documentation of field

proc purr(self: Kitten) =
  ## Documentation of function
  echo "Purr Purr"  # This is a comment, but it is not a documentation comment.

# This is a comment, but it is not a documentation comment.

OCaml

OCaml använder nestbara kommentarer, vilket är användbart när du kommenterar ett kodblock. 

codeLine(* comment level 1(*comment level 2*)*)

Pascal

I Niklaus Wirths pascal- språkfamilj (inklusive Modula-2 och Oberon ) öppnas kommentarer med '(*' och kompletteras med '*)'.

till exempel: 

(* test diagonals *)
columnDifference := testColumn - column;
if (row + columnDifference = testRow) or
    .......

I moderna dialekter av Pascal används '{' och '}' istället.

Perl

Radkommentarer i Perl och många andra skriptspråk börjar med en hash -symbol (#). 

# A simple example
# 
my $s = "Wikipedia"; # Sets the variable s to "Wikipedia".
print $s . "\n";     # Add a newline character after printing

Istället för en vanlig blockkommentarkonstruktion använder Perl Plain Old Documentation , ett uppmärkningsspråk för läskunnig programmering , till exempel: 

=item Pod::List-E<gt>new()

Create a new list object. Properties may be specified through a hash
reference like this:

  my $list = Pod::List->new({ -start => $., -indent => 4 });

See the individual methods/properties for details.

=cut

sub new {
    my $this = shift;
    my $class = ref($this) || $this;
    my %params = @_;
    my $self = {%params};
    bless $self, $class;
    $self->initialize();
    return $self;
}

R

R stöder bara inline kommentarer som startas av hash (#) tecknet. 

# This is a comment
print("This is not a comment")  # This is another comment

Raku

Raku (tidigare kallad Perl 6) använder samma radkommentarer och POD-dokumentationskommentarer som vanliga Perl (se avsnittet Perl ovan), men lägger till en konfigurerbar blockkommentartyp: "flera rader / inbäddade kommentarer".

Dessa börjar med ett hash -tecken, följt av en backtick, och sedan något öppnande bracketing -tecken, och slutar med det matchande avslutande bracketing -tecknet. Innehållet kan inte bara sträcka sig över flera rader, utan kan också vara inbäddat inline. 

#`{{ "commenting out" this version 
toggle-case(Str:D $s)

Toggles the case of each character in a string:

  my Str $toggled-string = toggle-case("mY NAME IS mICHAEL!");

}}

sub toggle-case(Str:D $s) #`( this version of parens is used now ){
    ...
}

PHP

Kommentarer i PHP kan antingen vara i C ++ - stil (både inline och block) eller använda hash. PHPDoc är en stil anpassad från Javadoc och är en vanlig standard för att dokumentera PHP -kod.

PowerShell

Kommentarer i Windows PowerShell 

# Single line comment
Write-Host "Hello, World!"

<# Multi
   Line
   Comment #>

Write-Host "Goodbye, world!"

Pytonorm

Inline -kommentarer i Python använder hash -tecknet (#), som i de två exemplen i den här koden: 

# This program prints "Hello World" to the screen
print("Hello World!")  # Note the new syntax

Blockkommentarer, enligt definitionen i den här artikeln, finns inte tekniskt sett i Python. En ren sträng bokstavligen representerad av en trippelciterad sträng kan användas, men ignoreras inte av tolken på samma sätt som "#" kommentar är. I exemplen nedan fungerar de trippel dubbelciterade strängarna på detta sätt som kommentarer, men behandlas också som dokument : 

"""
Assuming this is file mymodule.py, then this string, being the
first statement in the file, will become the "mymodule" module's
docstring when the file is imported.
"""

class MyClass:
    """The class's docstring"""

    def my_method(self):
        """The method's docstring"""

def my_function():
    """The function's docstring"""

Rubin

Kommentarer i Ruby .

Kommentarer från en rad: (rad börjar med hash "#") 

puts "This is not a comment"

# this is a comment

puts "This is not a comment"

Flerradig kommentar: (kommentarer går mellan sökorden "börja" och "slut") 

puts "This is not a comment"

=begin

whatever goes in these lines

is just for the human reader

=end

puts "This is not a comment"

SQL

Standardkommentarer i SQL finns endast i en rad, med två bindestreck: 

-- This is a single line comment
-- followed by a second line
SELECT COUNT(*)
       FROM Authors
       WHERE Authors.name = 'Smith'; -- Note: we only want 'smith'
                                     -- this comment appears after SQL code

Alternativt stöds en kommentarformatsyntax som är identisk med stilen "blockkommentar" som används i syntaxen för C och Java av Transact-SQL , MySQL , SQLite , PostgreSQL och Oracle .

MySQL stöder också kommentarer från hashtecknet (#) till slutet av raden.

Snabb

Enradiga kommentarer börjar med två snedstreck (//):

// This is a comment.

Flerradiga kommentarer börjar med ett snedstreck följt av en asterisk (/*) och slutar med en asterisk följt av ett snedstreck (*/):

/* This is also a comment
 but is written over multiple lines. */

Flerradiga kommentarer i Swift kan häckas inuti andra flerfältskommentarer. Du skriver kapslade kommentarer genom att starta ett flerlinjeskommentarblock och sedan starta en andra flerradig kommentar inom det första blocket. Det andra blocket stängs sedan, följt av det första blocket:

/* This is the start of the first multiline comment.
 /* This is the second, nested multiline comment. */
 This is the end of the first multiline comment. */

XML (eller HTML)

Kommentarer i XML (eller HTML) introduceras med

<!--

och kan spridas över flera linjer tills terminatorn, 

-->

Till exempel, 

<!-- select the context here -->
<param name="context" value="public" />

För kompatibilitet med SGML är strängen "-" (dubbel bindestreck) inte tillåten inuti kommentarer.

Säkerhetsproblem

På tolkade språk är kommentarerna synliga för slutanvändaren av programmet. I vissa fall, till exempel delar av kod som "kommenterade ut", kan detta utgöra en säkerhets sårbarhet .

Se även

Anteckningar och referenser

Vidare läsning

externa länkar