Porównanie języków programowania (składnia) - Comparison of programming languages (syntax)

To porównanie języków programowania porównuje cechy składni (formatu) języka dla ponad 50 języków programowania komputerowego.

Wyrażenia

Wyrażenia języka programowania można ogólnie podzielić na cztery struktury składni:

notacja przedrostkowa

Seplenienie (* (+ 2 3) (expt 4 5))

notacja wrostkowa

Fortran (2 + 3) * (4 ** 5)

przyrostek, przyrostek lub odwrotna notacja polska

Naprzód 2 3 + 4 5 ** *

notacja matematyczna

KOREPETYTOR (2 + 3)(4⁵) $$ note implicit multiply operator

Sprawozdania

Gdy języki programowania (zwykle potomkowie Algola ) mają instrukcje , zazwyczaj mają konwencje dla:

separatory instrukcji;
terminatory wypowiedzi; oraz
kontynuacja linii

Separator instrukcji służy do wyznaczania granic między dwoma oddzielnymi instrukcjami. Terminator instrukcji służy do wyznaczania końca poszczególnych instrukcji. Języki, które interpretują koniec wiersza jako koniec instrukcji, nazywane są językami „liniowymi”.

„Kontynuacja wiersza” to konwencja w językach zorientowanych wierszowo, w której znak nowego wiersza może być potencjalnie błędnie zinterpretowany jako terminator instrukcji. W takich językach pojedyncza instrukcja może obejmować więcej niż jedną linię.

Język	Separator-terminator wyciągu	Separator-terminator wtórny
ABAP	okres oddzielony
Ada	zakończony średnikiem
ALGOL	oddzielone średnikiem
ALGOL 68	średnik i przecinek oddzielone
APL	zakończenie nowej linii	`[Direct_function ⋄]` oddzielone drugorzędne
AppleScript	zakończenie nowej linii
Automatyczny klawisz skrótu	zakończenie nowej linii
PODSTAWOWY	zakończenie nowej linii	oddzielone dwukropkiem
Gwizd	zakończenie nowej linii
C	średnik kończy wypowiedzi	przecinek oddziela wyrażenia
C++	średnik kończy wypowiedzi	przecinek oddziela wyrażenia
C#	zakończony średnikiem
COBOL	oddzielone białymi znakami, czasem oddzielone kropkami, opcjonalnie oddzielone przecinkami i średnikami.
Kobra	zakończenie nowej linii
CoffeeScript	zakończenie nowej linii
CSS	oddzielone średnikiem
D	zakończony średnikiem
Eiffla	zakończenie nowej linii	średnik
Erlang	dwukropek oddzielony, okres zakończony
F#	zakończenie nowej linii	średnik
Fortran	zakończenie nowej linii	średnik
Naprzód	średniki kończą definicje słów. spacja kończy użycie słowa
PODSTAWOWE GFA	zakończenie nowej linii
Udać się	rozdzielone średnikami (wstawiane przez kompilator)
Haskell (w notacji)	oddzielona nowa linia
Haskell (w notacji, gdy używane są nawiasy klamrowe)	oddzielone średnikiem
Jawa	zakończony średnikiem
JavaScript	rozdzielone średnikami (ale czasami wstawiane niejawnie w nowych wierszach)
Kotlin	rozdzielone średnikami (ale czasami wstawiane niejawnie w nowych wierszach)
Lua	oddzielone białymi znakami (opcjonalnie średnik)
Matematyka zwana także Wolfram	oddzielone średnikiem
MATLAB	zakończenie nowej linii	średnik lub przecinek
ŚWINKA zwana również M	znak nowej linii kończy zasięg linii, najbliższy „instrukcji”, jaką ma M.	spacja oddziela/kończy polecenie, umożliwiając wykonanie innego polecenia.
Nimi	zakończenie nowej linii
Obiekt Pascal również ( Delphi )	oddzielone średnikiem
Cel C	zakończony średnikiem
OCaml	oddzielone średnikiem
Pascal	oddzielone średnikiem
Perl	oddzielone średnikiem
PHP	zakończony średnikiem
Wybierz podstawowe	zakończenie nowej linii	oddzielone średnikiem
PowerShell	zakończenie nowej linii	oddzielone średnikiem
Prolog	rozdzielone przecinkami (spójnik), rozdzielone średnikami (dyfuzja), okres zakończony (klauzula)
Pyton	zakończenie nowej linii	średnik
r	zakończenie nowej linii	średnik
Raku	oddzielone średnikiem
czerwony	oddzielone białymi znakami
Rubin	zakończenie nowej linii	średnik
Rdza	średnik kończy wypowiedzi	przecinek oddziela wyrażenia
Scala	zakończenie nowej linii (opcjonalnie średnik)	średnik
Nasiona7	oddzielone średnikiem (dozwolone zakończenie średnikiem)
Symulacja	oddzielone średnikiem
Gwara	oddzielone średnikiem
Pogawędka	okres oddzielony
Standardowy ML	oddzielone średnikiem
Szybki	rozdzielone średnikami (wstawiane przez kompilator)
Visual Basic	zakończenie nowej linii	oddzielone dwukropkiem
Visual Basic .NET	zakończenie nowej linii	oddzielone dwukropkiem
Język Wolfram	oddzielone średnikiem
Xojo	zakończenie nowej linii
Język	Separator-terminator wyciągu	Separator-terminator wtórny

Kontynuacja linii

Kontynuacja wiersza jest zwykle wykonywana jako część analizy leksykalnej : znak nowej linii zwykle powoduje dodanie znacznika do strumienia znaczników, chyba że zostanie wykryta kontynuacja wiersza.

Białe znaki – języki, które nie wymagają kontynuacji

Ada – Linie kończą się średnikiem
C# – Linie kończą się średnikiem
JavaScript – wiersze kończą się średnikiem (co można wywnioskować)
Lua
OCaml

Ampersand jako ostatni znak linii

Fortran 90 , Fortran 95 , Fortran 2003 , Fortran 2008

Odwrotny ukośnik jako ostatni znak linii

bash i inne powłoki Unix
Preprocesor C i C++
Matematyka i język Wolfram
Pyton
Rubin
JavaScript – tylko w obrębie pojedynczych lub podwójnych cudzysłowów

Backtick jako ostatni znak linii

PowerShell

Łącznik jako ostatni znak wiersza

SQL*Plus

Podkreśl jako ostatni znak wiersza

Wielokropek (jako trzy kropki, a nie jeden znak specjalny)

MATLAB : Token wielokropka nie musi być ostatnimi znakami w wierszu, ale każdy następny znak zostanie zignorowany. (Zasadniczo rozpoczyna się komentarz, który rozciąga się do (tj. włącznie) pierwszego kolejnego znaku nowej linii. Porównaj to z komentarzem wstawianym, który rozciąga się aż do pierwszego kolejnego znaku nowej linii.)

Separator przecinków jako ostatni znak wiersza

Rubin (komentarz może następować po ograniczniku)

Ogranicznik lewego nawiasu jako ostatni znak wiersza

Plik wsadowy : rozpoczęcie bloku w nawiasie może umożliwić kontynuację wiersza
Ruby: lewy nawias, lewy nawias kwadratowy lub lewy nawias klamrowy

Operator jako ostatni obiekt linii

Ruby (komentarz może następować po operatorze)

Operator jako pierwszy znak kontynuowanej linii

AutoHotkey : Dowolne operatory wyrażeń z wyjątkiem ++ i --, a także przecinka lub kropki

Odwrotny ukośnik jako pierwszy znak kontynuowanej linii

Vimscript

Jakaś forma komentarza w wierszu służy jako kontynuacja wiersza

Monter turbosprężarek :\
m4 :dnl
TeX :%

Pozycja postaci

Fortran 77 : Wiersz bez komentarza jest kontynuacją poprzedniego wiersza bez komentarza, jeśli w kolumnie 6 pojawia się jakikolwiek znak inny niż spacja. Wiersze komentarza nie mogą być kontynuowane.
COBOL : Stałe łańcuchowe można kontynuować, nie kończąc oryginalnego łańcucha w klauzuli PICTURE znakiem ', a następnie wstawiając znak -w kolumnie 7 (ta sama pozycja, jak w *przypadku komentarza for).
TUTOR : Linie zaczynające się od tabulatora (po jakimkolwiek wcięciu wymaganym przez kontekst) kontynuują poprzednie polecenie.

[Koniec i początek] przy użyciu zwykłych cudzysłowów

Preprocesor C i C++ : ciąg kończy się normalnie i kontynuuje, zaczynając od cudzysłowu w następnym wierszu.

Biblioteki

Aby zaimportować do biblioteki jest sposobem, aby przeczytać zewnętrznych, ewentualnie zestawiać, procedury, programy lub pakiety. Importy można klasyfikować według poziomu (moduł, pakiet, klasa, procedura,...) i składni (nazwa dyrektywy, atrybuty,...)

Import pliku

addpath(directory)MATLAB
COPY filename.COBOL
:-include("filename"). Prolog
#include file="filename" ŻMIJA
#include "filename", AutoHotkey , AutoIt , C , C++
#include <filename>AutoHotkey , AutoIt , C , C++
#import "filename", Cel-C
#import <filename> Cel C
Import["filename"]Matematyka i język Wolfram
include 'filename'Fortran
include "filename";PHP
include [filename] program, Wybierz podstawowe
#include [filename] program Wybierz podstawowe
include!( "filename");Rdza
load "filename"Sokół
load %filenameczerwony
require("filename")Lua
require "filename"; Perl , PHP
source(""filename"")r

Import paczek

#include filename C , C++
#[path = "filename"] mod altname;, rdza
@import module; Cel C
<<name Matematyka i język Wolfram
:-use_module(module). Prolog :
from module import * Pyton
extern crate libname;, rdza
extern crate libname as altname; Rdza
mod modname;, rdza
library("package") R :
load module, Sokół
load module.submoduleSokół
IMPORT module Oberon
import altname "package/name" Idź :
import package.module;, D
import altname = package.module; D
import Module, Haskell
import qualified Module as M Haskell
import package.* Java , MATLAB , kotlin
import "modname"; JavaScript :
import altname from "modname";, JavaScript :
import package Scala
import package._, Scala
import module Szybki
import module, Python
require("modname") Lua :
use module, Fortran 90 +
use module, only : identifier Fortran 90 +
use Module;, Perl
use Module qw(import options);Perl
use Package.Name Kobra
uses unit Pascal
with package Ada

Import klas

from module import class Pyton
import class Sokół
import package.class Java , MATLAB , kotlin
import class from "modname";, JavaScript
import {class} from "modname";, JavaScript
import {class as altname} from "modname";JavaScript
import package.class, Scala
import package.{ class1 => alternativeName, class2 }, Scala
import package._Scala
use Namespace\ClassName;, PHP
use Namespace\ClassName as AliasName; PHP

Import procedur/funkcji

from module import function Pyton :
import package.module : symbol;, D :
import package.module : altsymbolname = symbol; D :
import Module (function) Haskell :
import function from "modname";, JavaScript :
import {function} from "modname";, JavaScript :
import {function as altname} from "modname";JavaScript :
import package.function MATLAB :
import package.class.function, Scala :
import package.class.{ function => alternativeName, otherFunction }Scala :
use Module ('symbol');Perl :
use function Namespace\function_name;, PHP :
use Namespace\function_name as function_alias_name; PHP :
use module::submodule::symbol;, rdza :
use module::submodule::{symbol1, symbol2};, rdza :
use module::submodule::symbol as altname; Rdza :

Stały import

use const Namespace\CONST_NAME; PHP

Powyższe stwierdzenia mogą być również klasyfikowane według tego, czy są wygodą składniową (pozwalając na odwoływanie się do rzeczy za pomocą krótszej nazwy, ale nadal można się do nich odwoływać za pomocą w pełni kwalifikowanej nazwy bez importu), czy też faktycznie są wymagane, aby uzyskać dostęp kod (bez którego nie można uzyskać dostępu do kodu, nawet przy w pełni kwalifikowanych nazwach).

Wygoda syntaktyczna

import package.* Jawa
import package.class Jawa
open module OCaml

Wymagany do kodu dostępu

import altname "package/name" Udać się
import altname from "modname";JavaScript
import modulePyton

Bloki

Blok jest zapisem do grupy dwóch lub więcej instrukcji, wyrażeń lub innych jednostek kodu, które są związane w taki sposób, aby zawierać całość.

Nawiasy klamrowe (znane również jako nawiasy klamrowe) {...}

Języki programowania nawiasów klamrowych : C , C++ , Objective-C , Go , Java , JavaScript / ECMAScript , C# , D , Perl , PHP ( for& looppętle lub przekaż blok jako argument ), R , Rust , Scala , S-Lang , Swift , Windows PowerShell , Haskell (w notacji), AutoHotkey

Nawiasy (...)

OCaml , Prolog , Standard ML

Nawiasy kwadratowe [...]

Smalltalk (bloki to obiekty pierwszej klasy. aka zamknięcia)

begin ... end

Ada , ALGOL , Pascal , Ruby ( for, do/whilei do/untilpętelki) OCaml , SCL , Simula , Erlang .

do ... end

PL/I , REXX

do ... done

Bash ( for& whilepętle), Visual Basic , Fortran , TUTOR (z obowiązkowym wcięciem treści bloku), Visual Prolog

do ... end

Lua , Ruby (przekaż bloki jako argumenty, forpętlę), Seed7 (zawiera ciała pętli między doi end)

X ... end(np. if... end):

Ruby ( if, while, until, def, class, moduleinstrukcje), OCaml ( for& whilepętle), MATLAB ( if& switchwarunkowe, for& whilepętle, tryklauzula, package, classdef, properties, methods, events, & functionbloki), Lua ( then/ else& function)

( begin...)

Schemat

(prog...)

Seplenienie

( do...)

Clojure

Wcięcie

Języki reguł off-side : Cobra , CoffeeScript , F# , Haskell (w notacji w przypadku pominięcia nawiasów klamrowych), occam , Python , Nim
Języki wolne : większość potomków ALGOL (w tym C , Pascal i Perl ); Języki lispu

Inni

Ada , Visual Basic , Seed7 : if...end if
APL : :If... :EndIflub :If...:End
Bash , sh i ksh : if... fi, do... done, case... esac;
ALGOL 68 : begin... end, (... ), if... fi, do...od
Lua , Pascal , Modula-2 , Seed7 : repeat...until
COBOL : IF... END-IF, PERFORM... END-PERFORM, itp. dla oświadczeń; ... .dla zdań.
Visual Basic .Net : If... End If, For... Next, Do...Loop
Małe podstawowe : If... EndIf, For... EndFor, While...EndWhile

Uwagi

Komentarze można klasyfikować według:

styl (wbudowany/blok)
parsowanie reguł (ignorowane/interpolowane/przechowywane w pamięci)
rekursywność (zagnieżdżona/niezagnieżdżona)
zastosowania ( docstrings / wyrzucenie komentarzy / inne)

Komentarze w tekście

Komentarze śródliniowe to zazwyczaj te, w których znak nowej linii wskazuje koniec komentarza, a arbitralny ogranicznik lub sekwencja znaczników wskazuje początek komentarza.

Przykłady:

Symbol	Języki
`C`	Fortran I do Fortran 77 (C w kolumnie 1)
`REM`	PODSTAWOWE , Pliki wsadowe
`::`	Pliki wsadowe , COMMAND.COM , cmd.exe
`NB.`	J ; od (historycznie) powszechnego skrótu Nota bene , po łacinie oznaczającego „dobrze nutę”.
`⍝`	APL ; mnemonik to glif (jot przekreślony butem) przypomina lampę biurkową, a zatem „oświetla” powyższe.
`#`	Powłoka Bourne'a i inne powłoki UNIX , Cobra , Perl , Python , Ruby , Seed7 , Windows PowerShell , PHP , R , Make , Maple , Elixir , Nim
`%`	TeX , Prolog , MATLAB , Erlang , S-Lang , Visual Prolog
`//`	ActionScript , C (C99) , C++ , C# , D , F# , Go , Java , JavaScript , Kotlin , Object Pascal ( Delphi ), Objective-C , PHP , Rust , Scala , SASS , Swift , Xojo
`'`	Monkey, Visual Basic , VBScript , Small Basic , Gambas , Xojo
`!`	Fortran , Basic Plus, Inform, Pick Basic
`;`	Montaż x86 , AutoHotkey , AutoIt , Lisp , Common Lisp , Clojure , Rebol , Red , Scheme
`--`	Euforia , Haskell , SQL , Ada , AppleScript , Eiffel , Lua , VHDL , SGML , PureScript
`*`	Assembler S/360 (* w kolumnie 1), COBOL I do COBOL 85, PAW , Fortran IV do Fortran 77 (* w kolumnie 1), Pick Basic , GAMS (* w kolumnie 1)
`\|\|`	Kędzior
`"`	Vimscript , ABAP
`\`	Naprzód
`*>`	COBOL 90

Blokuj komentarze

Komentarze blokowe to zazwyczaj te, które używają ogranicznika do wskazania początku komentarza i innego ogranicznika do wskazania końca komentarza. W tym kontekście białe znaki i znaki nowego wiersza nie są liczone jako ograniczniki.

Przykłady:

Symbol	Języki
`comment` ~ `;`	ALGOL 60 , SIMULA
`¢`~ `¢`, `#`~ `#`, `co`~ `co`, `comment`~`comment`	ALGOL 68
`/` ~ `/`	ActionScript, AutoHotkey , C, C++, C#, D, Go, Java , JavaScript , kotlin , Objective-C , PHP , PL/I , Prolog , Rexx , Rust (może być zagnieżdżony), Scala (może być zagnieżdżony), SAS , SASS, SQL, Swift (może być zagnieżdżony), Visual Prolog , CSS
`#cs` ~ `#ce`	AutoIt
`/+` ~ `+/`	D (może być zagnieżdżony)
`/#` ~ `#/`	Kobra (może być zagnieżdżona)
`<#` ~ `#>`	Powershell
`<!--` ~ `-->`	HTML , XML
`=begin` ~ `=cut`	Perl
#`( ~ `)`	Raku (znakami w nawiasach mogą być (), <>, {}, [], dowolne znaki Unicode z odbiciami BiDi lub znaki Unicode z właściwościami Ps/Pe/Pi/Pf)
`=begin` ~ `=end`	Rubin
`#<TAG>`~ , ~ , ~ , ~ , ~ , ~`#</TAG>#stopEOF` `#iffalse#endif#ifntrue#endif` `#if false#endif#if !true#endif`	Gwara
`{-` ~ `-}`	Haskell (może być zagnieżdżony)
`(` ~ `)`	Delphi , ML, Mathematica, Object Pascal, Pascal , Seed7 , Applescript , OCaml (może być zagnieżdżony), Standard ML (może być zagnieżdżony), Maple, Newspeak , F#
`{` ~ `}`	Delphi, Obiekt Pascal, Pascal, Czerwony
`{#` ~ `#}`	Nunjucks, Gałązka
`{{!` ~ `}}`	Wąsy , Kierownice
`{{!--` ~ `--}}`	Kierownice (nie mogą być zagnieżdżone, ale mogą zawierać `{{`i `}}`)
`\|#` ~ `#\|`	Kędzior
`%{` ~ `%}`	MATLAB (symbole muszą znajdować się w osobnym wierszu)
`#\|` ~ `\|#`	Lisp , Scheme , Racket (może być zagnieżdżony we wszystkich trzech).
`#[` ~ `]#`	Nimi
`--[[`~ `]]`, `--[=[`~ `]=]`, `--[=`... `=[`~ `]=`...`=]`	Lua (nawiasy mogą mieć dowolną liczbę pasujących znaków =; mogą być zagnieżdżone w niepasujących ogranicznikach)
`"` ~ `"`	Pogawędka
`(comment` ~ `)`	Clojure

Unikalne warianty

Fortran

Linie wcięć w Fortranie 66/77 są znaczące. Rzeczywiste zestawienie znajduje się w kolumnach od 7 do 72 wiersza. Każdy znak inny niż spacja w kolumnie 6 wskazuje, że ten wiersz jest kontynuacją poprzedniego wiersza. Znak „ C” w kolumnie 1 oznacza, że cały ten wiersz jest komentarzem. Kolumny od 1 do 5 mogą zawierać liczbę, która służy jako etykieta. Kolumny od 73 do 80 są ignorowane i mogą być używane do komentarzy; w czasach kart dziurkowanych kolumny te często zawierały numer kolejny, aby talię kart można było posortować we właściwej kolejności, gdyby ktoś przypadkowo upuścił karty. Fortran 90 usunął potrzebę reguły wcięcia i dodał wbudowane komentarze, używając !znaku jako ogranicznika komentarza.

COBOL

W kodzie o stałym formacie wcięcie wiersza jest znaczące. Kolumny 1–6 i kolumny od 73 są ignorowane. Jeśli w kolumnie 7 jest *lub /, to ten wiersz jest komentarzem. Aż do COBOL 2002, jeśli w kolumnie 7 znajdowała się a Dlub d, definiowała ona "linię debugowania", która byłaby ignorowana, chyba że kompilator został poinstruowany, aby ją skompilować.

Kobra

Cobra obsługuje komentarze blokowe z " /#... #/" , co jest podobne do " /*... */" często spotykanego w językach opartych na C, ale z dwiema różnicami. #Znak jest wykorzystywany od postaci komentarza pojedynczej linii „ #...”, a komentarze blokowe mogą być zagnieżdżone, które jest wygodne dla zakomentowanie dużych bloków kodu.

Kędzior

Curl obsługuje komentarze blokowe ze znacznikami zdefiniowanymi przez użytkownika, jak w |foo# ... #foo|.

Lua

Podobnie jak w przypadku surowych łańcuchów, pomiędzy nawiasami kwadratowymi może znajdować się dowolna liczba znaków równości, pod warunkiem, że zarówno znacznik otwierający, jak i zamykający mają taką samą liczbę znaków równości; pozwala to na zagnieżdżanie, o ile zagnieżdżone komentarze blokowe/surowe ciągi znaków używają innej liczby znaków równości niż komentarz zawierający: --[[comment --[=[ nested comment ]=] ]]. Lua odrzuca pierwszy znak nowej linii (jeśli jest obecny), który występuje bezpośrednio po otwierającym znaczniku.

Perl

Komentarze blokowe w Perlu są uważane za część dokumentacji i noszą nazwę Plain Old Documentation (POD). Technicznie rzecz biorąc, Perl nie ma konwencji umieszczania komentarzy blokowych w kodzie źródłowym, ale POD jest rutynowo używany jako obejście.

PHP

PHP obsługuje standardowe komentarze w stylu C/C++, ale obsługuje również styl Perl.

Pyton

Użycie potrójnych cudzysłowów do skomentowania wierszy źródła nie tworzy w rzeczywistości komentarza. Załączony tekst staje się literałem ciągu, który Python zwykle ignoruje (z wyjątkiem sytuacji, gdy jest to pierwsza instrukcja w ciele modułu, klasy lub funkcji; zobacz docstring ).

Raku

Raku używa #`(...)do oznaczania komentarzy blokowych. Raku faktycznie pozwala na użycie dowolnych "prawych" i "lewych" sparowanych nawiasów po #`(np. #`(...), #`[...], #`{...}, #`<...>, a nawet bardziej skomplikowane #`{{...}}są poprawne komentarze blokowe). Dopuszcza się również zagnieżdżanie #`{ a { b } c }nawiasów wewnątrz komentarzy (tzn. przejście do ostatniego nawiasu zamykającego).

Rubin

Komentarz blokowy w Rubim otwiera się w =beginwierszu i zamyka w =endwierszu.

Gwara

Region linii ujęty przez ograniczniki #<tag>i #</tag>jest ignorowany przez interpreter. Nazwa znacznika może być dowolną sekwencją znaków alfanumerycznych, która może być użyta do wskazania, w jaki sposób należy odszyfrować załączony blok. Na przykład #<latex>może wskazywać początek bloku dokumentacji w formacie LaTeX.

Schemat i rakieta

Następny kompletny składnik składniowy (wyrażenie s) można zakomentować za pomocą #;.

ABAP

ABAP obsługuje dwa różne rodzaje komentarzy. Jeśli pierwszym znakiem wiersza, łącznie z wcięciem, jest gwiazdka ( *), cały wiersz jest traktowany jako komentarz, podczas gdy pojedynczy podwójny cudzysłów ( ") rozpoczyna komentarz w wierszu, który działa do końca wiersza. Komentarze ABAP nie są możliwe między instrukcjami EXEC SQLi ENDEXECponieważ Native SQL ma inne zastosowania dla tych znaków. W większości dialektów SQL --można zamiast tego użyć podwójnego myślnika ( ).

Języki ezoteryczne

Wiele ezoterycznych języków programowania przestrzega konwencji, że każdy tekst, który nie jest wykonywany przez wskaźnik instrukcji (np. Befunge ) lub w inny sposób ma przypisane znaczenie (np. Brainfuck ), jest uważany za „komentarz”.

Porównanie komentarzy

Istnieje wiele różnych stylów składni do deklarowania komentarzy w kodzie źródłowym. BlockCommentpisany kursywą służy tutaj do oznaczenia stylu komentarza blokowego. InlineCommentpisany kursywą jest używany tutaj, aby wskazać styl komentarza w tekście.

Język	Komentarz w tekście	Zablokuj komentarz
Ada , Eiffel , Euphoria , Occam , SPARK , ANSI SQL i VHDL	`-- InlineComment`
ALGOL 60		`comment BlockComment;`
ALGOL 68		`¢ BlockComment ¢` `comment BlockComment comment` `co BlockComment co` `# BlockComment #` `£ BlockComment £`
APL	`⍝ InlineComment`
AppleScript	`-- InlineComment`	`(* BlockComment *)`
Język asemblera (różny)	`; InlineComment` jeden przykład (większość języków asemblerowych używa tylko komentarzy liniowych)
Automatyczny klawisz skrótu	`; InlineComment`	`/* BlockComment */`
AWK , atakujących , Bourne powłoki , powłoka C , klon , R , TCL i Windows PowerShell	`# InlineComment`	`<# BlockComment #>`
BASIC (różne dialekty):	`'InlineComment` (nie wszystkie dialekty) `*InlineComment (not all dialects)` `!InlineComment (not all dialects)` `REM InlineComment`
C (K&R, ANSI/C89/C90), CHILL , PL/I i REXX		`/* BlockComment */`
C (C99) , C++ , Go , Swift i JavaScript	`// InlineComment`	`/* BlockComment */`
C#	`// InlineComment` `/// InlineComment` (komentarz do dokumentacji XML)	`/* BlockComment /` `/* BlockComment */` (komentarz do dokumentacji XML)
COBOL I do COBOL 85	`* InlineComment` (* w kolumnie 7)
COBOL 2002	`*> InlineComment`
Kędzior	`\|\| InlineComment`	`\|# BlockComment #\|` `\|foo# BlockComment #\|`
Kobra	`# InlineComment`	`/# BlockComment #/` (gniazdo)
D	`// InlineComment` `/// Documentation InlineComment`( komentarze doc )	`/* BlockComment /` `/* Documentation BlockComment */`( komentarze doc ) `/+ BlockComment +/`(nestable) ( nestable, komentarze doc ) `/++ Documentation BlockComment +/`
DCL	`$! InlineComment`
ECMAScript ( JavaScript , ActionScript itp.)	`// InlineComment`	`/* BlockComment */`
Naprzód	`\ InlineComment`	`( BlockComment )` (pojedyncza i wielowierszowa) `( before -- after )` konwencja komentarzy stosu
FORTRAN I do FORTRAN 77	`C InlineComment` (C w kolumnie 1)
Fortran 90	`! InlineComment`
Haskell	`-- InlineComment`	`{- BlockComment -}`
Jawa	`// InlineComment`	`/* BlockComment /` `/* BlockComment */`( Komentarz dokumentacji Javadoc )
Lisp i schemat	`; InlineComment`	`#\| BlockComment \|#`
Lua	`-- InlineComment`	`--[==[ BlockComment]==]` (zmienna liczba znaków =)
Klon	`# InlineComment`	`(* BlockComment *)`
Matematyka		`(* BlockComment *)`
Matlab	`% InlineComment`	`%{ BlockComment (nestable) %}` Uwaga: Oba symbole nawiasów procentowych muszą być jedynymi znakami niebędącymi odstępami w odpowiednich wierszach.
Nimi	`# InlineComment`	`#[ BlockComment ]#`
Obiekt Pascal	`// InlineComment`	`(* BlockComment *)` `{ BlockComment }`
OCaml		`(* BlockComment (* nestable ) )`
Pascal , Modula-2 , Modula-3 , Oberon i ML :		`(* BlockComment *)`
Perl i Ruby	`# InlineComment`	`=begin BlockComment =cut`( `=end`w języku Ruby) ( komentarz dokumentacji POD ) `__END__ Comments after end of code`
PHP	`# InlineComment` `// InlineComment`	`/* BlockComment /` `/* Documentation BlockComment */`( Komentarze dokumentu PHP )
PILOT	`R:InlineComment`
PLZ/SYS		`! BlockComment !`
PL/SQL i TSQL	`-- InlineComment`	`/* BlockComment */`
Prolog	`% InlineComment`	`/* BlockComment */`
Pyton	`# InlineComment`	`''' BlockComment ''' """ BlockComment """` ( Ciąg dokumentacji, gdy pierwszy wiersz modułu, klasy, metody lub funkcji)
r	`# InlineComment`
Raku	`# InlineComment`	#`{ BlockComment } `=comment This comment paragraph goes until the next POD directive or the first blank line.`
czerwony	`; InlineComment`	`{ BlockComment }`
Rdza	`// InlineComment` `/// InlineComment` („Zewnętrzny” komentarz rustdoc) („Wewnętrzny” komentarz rustdoc) `//! InlineComment`	`/* BlockComment /` (gniazdo) `/* BlockComment /` („Zewnętrzny” komentarz rustdoc) („Wewnętrzny” komentarz rustdoc) `/! BlockComment */`
SAS		`* BlockComment;` `/* BlockComment */`
Nasiona7	`# InlineComment`	`(* BlockComment *)`
Symulacja		`comment BlockComment;` `! BlockComment;`
Pogawędka		`"BlockComment"`
Smarty		`{* BlockComment *}`
Standardowy ML		`(* BlockComment *)`
TeX , LaTeX , PostScript , Erlang , Elixir i S-Lang	`% InlineComment`
Texinfo	`@c InlineComment` `@comment InlineComment`
KOREPETYTOR	`* InlineComment` `command $$ InlineComment`
Visual Basic	`' InlineComment` `Rem InlineComment`
Visual Basic .NET	`' InlineComment` `''' InlineComment` (komentarz do dokumentacji XML) `Rem InlineComment`
Prolog wizualny	`% InlineComment`	`/* BlockComment */`
Język Wolfram		`(* BlockComment *)`
Xojo	`' InlineComment` `// InlineComment` `rem InlineComment`

Zobacz też

Składnia C
Składnia C++
Języki programowania nawiasów klamrowych , szeroka rodzina składni języka programowania
Składnia Javy
Składnia JavaScript
Składnia i semantyka PHP
Składnia i semantyka Pythona

Languages

In other projects