Comparação de linguagens de programação (sintaxe) - Comparison of programming languages (syntax)

Esta comparação de linguagens de programação compara os recursos da sintaxe da linguagem (formato) para mais de 50 linguagens de programação de computador.

Expressões

Expressões de linguagem de programação podem ser amplamente classificadas em quatro estruturas de sintaxe:

notação de prefixo

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

notação infixo

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

sufixo, postfix ou notação polonesa reversa

Adiante 2 3 + 4 5 ** *

notação matemática

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

Afirmações

Quando as linguagens de programação (geralmente descendentes de Algol ) têm instruções, elas normalmente têm convenções para:

separadores de declaração;
terminadores de instrução; e
continuação de linha

Um separador de instrução é usado para demarcar os limites entre duas instruções separadas. Um terminador de instrução é usado para demarcar o final de uma instrução individual. As linguagens que interpretam o fim de linha como o fim de uma instrução são chamadas de linguagens "orientadas a linhas".

"Continuação de linha" é uma convenção em linguagens orientadas a linha em que o caractere de nova linha pode ser interpretado incorretamente como um terminador de instrução. Nessas linguagens, permite que uma única instrução ocupe mais de uma linha.

Língua	Separador-terminador de instrução	Separador-terminador secundário
ABAP	período separado
Ada	ponto e vírgula terminado
ALGOL	separados por ponto e vírgula
ALGOL 68	separados por ponto e vírgula e vírgula
APL	nova linha terminada	`[Direct_function ⋄]` Secundário separado
AppleScript	nova linha terminada
AutoHotkey	nova linha terminada
BASIC	nova linha terminada	dois pontos separados
Vaia	nova linha terminada
C	ponto-e-vírgula termina as declarações	vírgula separa expressões
C ++	ponto-e-vírgula termina as declarações	vírgula separa expressões
C #	ponto e vírgula terminado
COBOL	separados por espaços em branco, às vezes separados por ponto, opcionalmente separados por vírgulas e ponto e vírgula.
Cobra	nova linha terminada
CoffeeScript	nova linha terminada
CSS	separados por ponto e vírgula
D	ponto e vírgula terminado
Eiffel	nova linha terminada	ponto e vírgula
Erlang	separados por dois pontos, ponto final
F #	nova linha terminada	ponto e vírgula
Fortran	nova linha terminada	ponto e vírgula
Adiante	ponto-e-vírgulas encerram as definições de palavras. espaço termina o uso de palavras
GFA BASIC	nova linha terminada
Ir	separados por ponto e vírgula (inserido pelo compilador)
Haskell (em notação)	nova linha separada
Haskell (em notação, quando colchetes são usados)	separados por ponto e vírgula
Java	ponto e vírgula terminado
JavaScript	separados por ponto e vírgula (mas às vezes inseridos implicitamente em novas linhas)
Kotlin	separados por ponto e vírgula (mas às vezes inseridos implicitamente em novas linhas)
Lua	separados por espaços em branco (ponto e vírgula opcional)
Mathematica também chamado de Wolfram	separados por ponto e vírgula
MATLAB	nova linha terminada	ponto e vírgula ou vírgula
MUMPS também chamado de M	newline termina o escopo da linha, o mais próximo de uma "declaração" que M tem.	um espaço separa / define um comando, permitindo que outro comando o siga.
Nim	nova linha terminada
Object Pascal também ( Delphi )	separados por ponto e vírgula
Objective-C	ponto e vírgula terminado
OCaml	separados por ponto e vírgula
Pascal	separados por ponto e vírgula
Perl	separados por ponto e vírgula
PHP	ponto e vírgula terminado
Escolha Básico	nova linha terminada	separados por ponto e vírgula
PowerShell	nova linha terminada	separados por ponto e vírgula
Prolog	separados por vírgula (conjunção), separados por ponto e vírgula (disjunção), ponto final (cláusula)
Pitão	nova linha terminada	ponto e vírgula
R	nova linha terminada	ponto e vírgula
Raku	separados por ponto e vírgula
vermelho	espaços em branco separados
Rubi	nova linha terminada	ponto e vírgula
Ferrugem	ponto-e-vírgula termina as declarações	vírgula separa expressões
Scala	terminada por nova linha (ponto-e-vírgula opcional)	ponto e vírgula
Seed7	separados por ponto-e-vírgula (o término de ponto-e-vírgula é permitido)
Simula	separados por ponto e vírgula
Gíria	separados por ponto e vírgula
Conversa fiada	período separado
ML padrão	separados por ponto e vírgula
Rápido	separados por ponto e vírgula (inserido pelo compilador)
Visual básico	nova linha terminada	dois pontos separados
Visual Basic .NET	nova linha terminada	dois pontos separados
Wolfram Language	separados por ponto e vírgula
Xojo	nova linha terminada
Língua	Separador-terminador de instrução	Separador-terminador secundário

Continuação de linha

A continuação de linha geralmente é feita como parte da análise lexical : uma nova linha normalmente resulta em um token sendo adicionado ao fluxo de tokens, a menos que a continuação de linha seja detectada.

Espaço em branco - idiomas que não precisam de continuação

Ada - as linhas terminam com ponto e vírgula
C # - As linhas terminam com ponto e vírgula
JavaScript - as linhas terminam com ponto e vírgula (que pode ser inferido)
Lua
OCaml

E comercial como último caractere da linha

Fortran 90 , Fortran 95 , Fortran 2003 , Fortran 2008

Barra invertida como último caractere da linha

bash e outros shells Unix
Pré- processador C e C ++
Mathematica e Wolfram Language
Pitão
Rubi
JavaScript - somente em strings com aspas simples ou duplas

Backtick como último caractere da linha

PowerShell

Hífen como último caractere da linha

SQL * Plus

Sublinhado como último caractere da linha

Reticências (como três pontos - não um caractere especial)

MATLAB : O token de reticências não precisa ser o último caractere da linha, mas qualquer um que o seguir será ignorado. (Em essência, ele começa um comentário que se estende por meio (ou seja, incluindo) o primeiro caractere de nova linha subsequente. Compare isso com um comentário embutido, que se estende até a primeira linha de nova subsequente.)

Delimitador de vírgula como último caractere da linha

Ruby (o comentário pode seguir o delimitador)

Delimitador de colchete esquerdo como último caractere da linha

Arquivo de lote : iniciar um bloco entre parênteses pode permitir a continuação da linha
Ruby: parêntese esquerdo, colchete esquerdo ou colchete esquerdo

Operador como último objeto da linha

Ruby (o comentário pode seguir o operador)

Operador como primeiro caractere da linha contínua

AutoHotkey : qualquer operador de expressão, exceto ++ e -, bem como uma vírgula ou um ponto

Barra invertida como primeiro caractere da linha contínua

Vimscript

Alguma forma de comentário embutido serve como continuação da linha

Turbo Assembler :\
m4 :dnl
TeX :%

Posição do personagem

Fortran 77 : Uma linha sem comentário é uma continuação da linha sem comentário anterior se qualquer caractere sem espaço aparecer na coluna 6. As linhas de comentário não podem ser continuadas.
COBOL : constantes de string podem ser continuadas não terminando a string original em uma cláusula PICTURE com e ', em seguida, inserindo um -na coluna 7 (a mesma posição do *comentário for é usada).
TUTOR : As linhas que começam com uma tabulação (após qualquer recuo exigido pelo contexto) continuam o comando anterior.

[End and Begin] usando aspas normais

Pré- processador C e C ++ : A string é encerrada normalmente e continua começando com uma aspa na próxima linha.

Bibliotecas

Para importar uma biblioteca é uma maneira de ler externos, possivelmente compilados, rotinas, programas ou pacotes. As importações podem ser classificadas por nível (módulo, pacote, classe, procedimento, ...) e por sintaxe (nome da diretiva, atributos, ...)

Importação de arquivo

addpath(directory)MATLAB
COPY filename.COBOL
:-include("filename"). Prolog
#include file="filename" ASP
#include "filename", AutoHotkey , AutoIt , C , C ++
#include <filename>AutoHotkey , AutoIt , C , C ++
#import "filename", Objective-C
#import <filename> Objective-C
Import["filename"]Mathematica e Wolfram Language
include 'filename'Fortran
include "filename";PHP
include [filename] program, Escolha Básico
#include [filename] program Escolha Básico
include!( "filename");Ferrugem
load "filename"Falcão
load %filenamevermelho
require("filename")Lua
require "filename"; Perl , PHP
source(""filename"")R

Importação de pacote

#include filename C , C ++
#[path = "filename"] mod altname;, Ferrugem
@import module; Objective-C
<<name Mathematica e Wolfram Language
:-use_module(module). Prolog :
from module import * Pitão
extern crate libname;, Ferrugem
extern crate libname as altname; Ferrugem
mod modname;, Ferrugem
library("package") R :
load module, Falcon
load module.submoduleFalcão
IMPORT module Oberon
import altname "package/name" Vá :
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 Rápido
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 Cobra
uses unit Pascal
with package Ada

Importação de classe

from module import class Pitão
import class Falcão
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

Importação de procedimento / função

from module import function Python :
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;, Ferrugem :
use module::submodule::{symbol1, symbol2};, Ferrugem :
use module::submodule::symbol as altname; Ferrugem :

Importação constante

use const Namespace\CONST_NAME; PHP

As declarações acima também podem ser classificadas se são uma conveniência sintática (permitindo que as coisas sejam referidas por um nome mais curto, mas ainda podem ser referidas por algum nome totalmente qualificado sem importação), ou se são realmente necessárias para acessar o código (sem o qual é impossível acessar o código, mesmo com nomes totalmente qualificados).

Conveniência sintática

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

Necessário para acessar o código

import altname "package/name" Ir
import altname from "modname";JavaScript
import modulePitão

Blocos

Um bloco é uma notação para um grupo de duas ou mais declarações, expressões ou outras unidades de código que estão relacionadas de forma a compreender um todo.

Chaves (também conhecidas como chaves) {...}

Linguagens de programação de colchetes : C , C ++ , Objective-C , Go , Java , JavaScript / ECMAScript , C # , D , Perl , PHP ( for& looploops, ou passar um bloco como argumento), R , Rust , Scala , S-Lang , Swift , Windows PowerShell , Haskell (em notação), AutoHotkey

Parênteses (...)

OCaml , Prolog , ML padrão

Colchetes [...]

Smalltalk (blocos são objetos de primeira classe. Também conhecidos como fechamentos)

begin ... end

Ada , ALGOL , Pascal , Ruby ( for, do/while& do/untilloops), OCaml , SCL , Simula , Erlang .

do ... end

PL / I , REXX

do ... done

Bash ( for& whileloops), Visual Basic , Fortran , TUTOR (com recuo obrigatório do corpo do bloco), Visual Prolog

do ... end

Lua , Ruby (passa blocos como argumentos, forloop), Seed7 (inclui corpos de loop entre doe end)

X ... end(por exemplo if... end):

Rubi ( if, while, until, def, class, moduledeclarações), OCaml ( fore whilelaços), MATLAB ( if& switchcondicionais, fore whileloops, trycláusula, package, classdef, properties, methods, events, e functionblocos), Lua ( then/ else& function)

( begin...)

Esquema

(progn ...)

Lisp

( do...)

Clojure

Recuo

Linguagens de regra off-side : Cobra , CoffeeScript , F # , Haskell (em notação quando as chaves são omitidas), occam , Python , Nim
Linguagens de forma livre : a maioria dos descendentes de ALGOL (incluindo C , Pascal e Perl ); Linguagens Lisp

Outros

Ada , Visual Basic , Seed7 : if...end if
APL : :If... :EndIfou :If...:End
Bash , sh e 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, etc. para declarações; ... .para frases.
Visual Basic .Net : If... End If, For... Next, Do...Loop
Básico pequeno : If... EndIf, For... EndFor, While...EndWhile

Comentários

Os comentários podem ser classificados por:

estilo (embutido / bloco)
analisar regras (ignorado / interpolado / armazenado na memória)
recursividade (aninhada / não aninhada)
usa ( docstrings / comentários descartáveis / outros)

Comentários inline

Os comentários embutidos são geralmente aqueles que usam um caractere de nova linha para indicar o final de um comentário e um delimitador arbitrário ou sequência de tokens para indicar o início de um comentário.

Exemplos:

Símbolo	línguas
`C`	Fortran I a Fortran 77 (C na coluna 1)
`REM`	BASIC , arquivos em lote
`::`	Arquivos em lote , COMMAND.COM , cmd.exe
`NB.`	J ; da (historicamente) abreviatura comum Nota bene , o latim para "observe bem".
`⍝`	APL ; o mnemônico é o glifo (rebatido com o sapato) se assemelha a uma luminária de mesa e, portanto, "ilumina" o anterior.
`#`	Bourne shell e outros shells 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
`;`	Assembly x86 , AutoHotkey , AutoIt , Lisp , Common Lisp , Clojure , Rebol , Red , Scheme
`--`	Euphoria , Haskell , SQL , Ada , AppleScript , Eiffel , Lua , VHDL , SGML , PureScript
`*`	Assembler S / 360 (* na coluna 1), COBOL I a COBOL 85, PAW , Fortran IV a Fortran 77 (* na coluna 1), Pick Basic , GAMS (* na coluna 1)
`\|\|`	Ondulação
`"`	Vimscript , ABAP
`\`	Adiante
`*>`	COBOL 90

Bloquear comentários

Os comentários em bloco são geralmente aqueles que usam um delimitador para indicar o início de um comentário e outro delimitador para indicar o final de um comentário. Nesse contexto, os caracteres de espaço em branco e de nova linha não são contados como delimitadores.

Exemplos:

Símbolo	línguas
`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 (pode ser aninhado), Scala (pode ser aninhado), SAS , SASS, SQL, Swift (pode ser aninhado), Visual Prolog , CSS
`#cs` ~ `#ce`	AutoIt
`/+` ~ `+/`	D (pode ser aninhado)
`/#` ~ `#/`	Cobra (pode ser aninhada)
`<#` ~ `#>`	Powershell
`<!--` ~ `-->`	HTML , XML
`=begin` ~ `=cut`	Perl
#`( ~ `)`	Raku (os caracteres de colchetes podem ser (), <>, {}, [], quaisquer caracteres Unicode com espelhamentos BiDi ou caracteres Unicode com propriedades Ps / Pe / Pi / Pf)
`=begin` ~ `=end`	Rubi
`#<TAG>`~ , ~ , ~ , ~ , ~ , ~`#</TAG>#stopEOF` `#iffalse#endif#ifntrue#endif` `#if false#endif#if !true#endif`	Gíria
`{-` ~ `-}`	Haskell (pode ser aninhado)
`(` ~ `)`	Delphi , ML, Mathematica, Object Pascal, Pascal , Seed7 , Applescript , OCaml (pode ser aninhado), Standard ML (pode ser aninhado), Maple, Novilíngua , F #
`{` ~ `}`	Delphi, Object Pascal, Pascal, Red
`{#` ~ `#}`	Nunjucks, Twig
`{{!` ~ `}}`	Bigode , guiador
`{{!--` ~ `--}}`	Guidão (não pode ser aninhado, mas pode conter `{{`e `}}`)
`\|#` ~ `#\|`	Ondulação
`%{` ~ `%}`	MATLAB (os símbolos devem estar em uma linha separada)
`#\|` ~ `\|#`	Lisp , Scheme , Racket (pode ser aninhado em todos os três).
`#[` ~ `]#`	Nim
`--[[`~ `]]`, `--[=[`~ `]=]`, `--[=`... `=[`~ `]=`...`=]`	Lua (os colchetes podem ter qualquer número de caracteres = correspondentes; podem ser aninhados dentro de delimitadores não correspondentes)
`"` ~ `"`	Conversa fiada
`(comment` ~ `)`	Clojure

Variantes únicas

Fortran

O recuo das linhas no Fortran 66/77 é significativo. A declaração real está nas colunas 7 a 72 de uma linha. Qualquer caractere sem espaço na coluna 6 indica que esta linha é uma continuação da linha anterior. Um ' C' na coluna 1 indica que toda a linha é um comentário. As colunas de 1 a 5 podem conter um número que serve como rótulo. As colunas 73 a 80 são ignoradas e podem ser usadas para comentários; na época dos cartões perfurados , essas colunas geralmente continham um número de sequência para que o baralho pudesse ser classificado na ordem correta se alguém deixasse cair acidentalmente os cartões. O Fortran 90 removeu a necessidade da regra de recuo e adicionou comentários embutidos, usando o !caractere como delimitador de comentário.

COBOL

No código de formato fixo, o recuo da linha é significativo. As colunas 1–6 e colunas de 73 em diante são ignoradas. Se um *ou /estiver na coluna 7, essa linha é um comentário. Até COBOL 2002, se um Dou destivesse na coluna 7, ele definiria uma "linha de depuração" que seria ignorada a menos que o compilador fosse instruído a compilá-la.

Cobra

O Cobra oferece suporte a comentários de bloco com " /#... #/", que é como o " /*... */" freqüentemente encontrado em linguagens baseadas em C, mas com duas diferenças. O #caractere é reutilizado a partir do formulário de comentário de linha única " #..." e os comentários de bloco podem ser aninhados, o que é conveniente para comentar grandes blocos de código.

Ondulação

Curl suporta comentários de bloco com tags definidas pelo usuário como em |foo# ... #foo|.

Lua

Como strings brutas, pode haver qualquer número de sinais de igual entre os colchetes, desde que as tags de abertura e fechamento tenham um número correspondente de sinais de igual; isso permite nidificação enquanto blocos de comentários aninhados / cordas matérias utilizar um número diferente de sinais de igual do que o seu comentário delimitador: --[[comment --[=[ nested comment ]=] ]]. Lua descarta a primeira nova linha (se houver) que segue diretamente a tag de abertura.

Perl

Os comentários de bloco em Perl são considerados parte da documentação e recebem o nome Plain Old Documentation (POD). Tecnicamente, Perl não tem uma convenção para incluir comentários de bloco no código-fonte, mas POD é usado rotineiramente como uma solução alternativa.

PHP

PHP suporta comentários no estilo C / C ++ padrão, mas também suporta o estilo Perl.

Pitão

O uso de aspas triplas para comentar as linhas da fonte, na verdade, não forma um comentário. O texto incluído torna-se um literal de string, que o Python geralmente ignora (exceto quando é a primeira instrução no corpo de um módulo, classe ou função; consulte docstring ).

Raku

Raku usa #`(...)para denotar comentários de bloqueio. Raku, na verdade, permite o uso de qualquer "direito" e "esquerda" suportes emparelhados depois #`(ou seja #`(...), #`[...], #`{...}, #`<...>, e até mesmo o mais complicado #`{{...}}são todos os blocos de comentários válidos). Os colchetes também podem ser aninhados dentro dos comentários (ou seja, #`{ a { b } c }vão até a última chave de fechamento).

Rubi

O comentário de bloco em Ruby abre na =beginlinha e fecha na =endlinha.

Gíria

A região das linhas delimitadas pelos delimitadores #<tag>e #</tag>são ignoradas pelo intérprete. O nome da tag pode ser qualquer sequência de caracteres alfanuméricos que podem ser usados para indicar como o bloco incluído deve ser decifrado. Por exemplo, #<latex>pode indicar o início de um bloco de documentação formatada em LaTeX.

Esquema e Raquete

O próximo componente sintático completo (s-expression) pode ser comentado com #;.

ABAP

ABAP oferece suporte a dois tipos diferentes de comentários. Se o primeiro caractere de uma linha, incluindo o recuo, for um asterisco ( *), toda a linha é considerada um comentário, enquanto uma aspa dupla simples ( ") inicia um comentário in-line que atua até o final da linha. Comentários ABAP não são possíveis entre as instruções EXEC SQLe ENDEXECporque o SQL nativo tem outros usos para esses caracteres. Na maioria dos dialetos SQL, o traço duplo ( --) pode ser usado.

Linguagens esotéricas

Muitas linguagens de programação esotéricas seguem a convenção de que qualquer texto não executado pelo ponteiro de instrução (por exemplo, Befunge ) ou de outra forma atribuído a um significado (por exemplo, Brainfuck ), é considerado um "comentário".

Comparação de comentários

Há uma grande variedade de estilos de sintaxe para declarar comentários no código-fonte. BlockCommentem itálico é usado aqui para indicar o estilo do comentário do bloco. InlineCommentem itálico é usado aqui para indicar o estilo de comentário embutido.

Língua	Comentário in-line	Bloquear comentário
Ada , Eiffel , Euphoria , Occam , SPARK , ANSI SQL e VHDL	`-- InlineComment`
ALGOL 60		`comment BlockComment;`
ALGOL 68		`¢ BlockComment ¢` `comment BlockComment comment` `co BlockComment co` `# BlockComment #` `£ BlockComment £`
APL	`⍝ InlineComment`
AppleScript	`-- InlineComment`	`(* BlockComment *)`
Linguagem de montagem (varia)	`; InlineComment` um exemplo (a maioria das linguagens de montagem usa apenas comentários de linha)
AutoHotkey	`; InlineComment`	`/* BlockComment */`
AWK , Bash , Bourne shell , C shell , Maple , R , Tcl e Windows PowerShell	`# InlineComment`	`<# BlockComment #>`
BASIC (vários dialetos):	`'InlineComment` (nem todos os dialetos) `*InlineComment (not all dialects)` `!InlineComment (not all dialects)` `REM InlineComment`
C (K&R, ANSI / C89 / C90), CHILL , PL / I e REXX		`/* BlockComment */`
C (C99) , C ++ , Go , Swift e JavaScript	`// InlineComment`	`/* BlockComment */`
C #	`// InlineComment` `/// InlineComment` (Comentário da documentação XML)	`/* BlockComment /` `/* BlockComment */` (Comentário da documentação XML)
COBOL I a COBOL 85	`* InlineComment` (* na coluna 7)
COBOL 2002	`*> InlineComment`
Ondulação	`\|\| InlineComment`	`\|# BlockComment #\|` `\|foo# BlockComment #\|`
Cobra	`# InlineComment`	`/# BlockComment #/` (encaixável)
D	`// InlineComment` `/// Documentation InlineComment`( comentários ddoc )	`/* BlockComment /` `/* Documentation BlockComment */`( comentários ddoc ) `/+ BlockComment +/`(aninhada) ( aninhada , comentários ddoc ) `/++ Documentation BlockComment +/`
DCL	`$! InlineComment`
ECMAScript ( JavaScript , ActionScript , etc.)	`// InlineComment`	`/* BlockComment */`
Adiante	`\ InlineComment`	`( BlockComment )` (linha única, bem como multilinha) `( before -- after )` convenção de comentários da pilha
FORTRAN I para FORTRAN 77	`C InlineComment` (C na coluna 1)
Fortran 90	`! InlineComment`
Haskell	`-- InlineComment`	`{- BlockComment -}`
Java	`// InlineComment`	`/* BlockComment /` `/* BlockComment */`( Comentário da documentação Javadoc )
Lisp e Scheme	`; InlineComment`	`#\| BlockComment \|#`
Lua	`-- InlineComment`	`--[==[ BlockComment]==]` (número variável de = sinais)
Bordo	`# InlineComment`	`(* BlockComment *)`
Mathematica		`(* BlockComment *)`
Matlab	`% InlineComment`	`%{ BlockComment (nestable) %}` Nota: Ambos os símbolos de colchetes de porcentagem devem ser os únicos caracteres sem espaço em branco em suas respectivas linhas.
Nim	`# InlineComment`	`#[ BlockComment ]#`
Object Pascal	`// InlineComment`	`(* BlockComment *)` `{ BlockComment }`
OCaml		`(* BlockComment (* nestable ) )`
Pascal , Modula-2 , Modula-3 , Oberon e ML :		`(* BlockComment *)`
Perl e Ruby	`# InlineComment`	`=begin BlockComment =cut`( `=end`em Ruby) ( comentário de documentação POD ) `__END__ Comments after end of code`
PHP	`# InlineComment` `// InlineComment`	`/* BlockComment /` `/* Documentation BlockComment */`( Comentários do documento PHP )
PILOTO	`R:InlineComment`
PLZ / SYS		`! BlockComment !`
PL / SQL e TSQL	`-- InlineComment`	`/* BlockComment */`
Prolog	`% InlineComment`	`/* BlockComment */`
Pitão	`# InlineComment`	`''' BlockComment ''' """ BlockComment """` ( String de documentação quando a primeira linha de módulo, classe, método ou função)
R	`# InlineComment`
Raku	`# InlineComment`	#`{ BlockComment } `=comment This comment paragraph goes until the next POD directive or the first blank line.`
vermelho	`; InlineComment`	`{ BlockComment }`
Ferrugem	`// InlineComment` `/// InlineComment` (Comentário rustdoc "externo") ( comentário rustdoc "interno") `//! InlineComment`	`/* BlockComment /` (encaixável) `/* BlockComment /` (Comentário rustdoc "externo") ( comentário rustdoc "interno") `/! BlockComment */`
SAS		`* BlockComment;` `/* BlockComment */`
Seed7	`# InlineComment`	`(* BlockComment *)`
Simula		`comment BlockComment;` `! BlockComment;`
Conversa fiada		`"BlockComment"`
Espertinho		`{* BlockComment *}`
ML padrão		`(* BlockComment *)`
TeX , LaTeX , PostScript , Erlang , Elixir e S-Lang	`% InlineComment`
Texinfo	`@c InlineComment` `@comment InlineComment`
TUTOR	`* InlineComment` `command $$ InlineComment`
Visual básico	`' InlineComment` `Rem InlineComment`
Visual Basic .NET	`' InlineComment` `''' InlineComment` (Comentário da documentação XML) `Rem InlineComment`
Visual Prolog	`% InlineComment`	`/* BlockComment */`
Wolfram Language		`(* BlockComment *)`
Xojo	`' InlineComment` `// InlineComment` `rem InlineComment`

Veja também

Sintaxe C
Sintaxe C ++
Linguagens de programação de colchetes curtos , uma ampla família de sintaxes de linguagem de programação
Sintaxe Java
Sintaxe JavaScript
Sintaxe e semântica de PHP
Sintaxe e semântica do Python

Languages

In other projects