Esta comparación de lenguajes de programación compara las características de la sintaxis del lenguaje (formato) para más de 50 lenguajes de programación de computadoras.
Expresiones
Las expresiones del lenguaje de programación se pueden clasificar ampliamente en cuatro estructuras de sintaxis:
- notación de prefijo
- Lisp (* (+ 2 3) (expt 4 5))
- notación infija
- Fortran (2 + 3) * (4 ** 5)
- sufijo, sufijo o notación polaca inversa
- Cuarto 2 3 + 4 5 ** *
- notación matemática
- TUTOR (2 + 3) (4 5 ) $$ nota operador de multiplicación implícito
Declaraciones
Cuando los lenguajes de programación (generalmente descendientes de Algol ) tienen declaraciones , generalmente tienen convenciones para:
- separadores de declaraciones;
- terminadores de declaraciones; y
- continuación de línea
Se utiliza un separador de declaraciones para demarcar los límites entre dos declaraciones separadas. Se utiliza un terminador de declaración para demarcar el final de una declaración individual. Los lenguajes que interpretan el final de la línea como el final de una declaración se denominan lenguajes "orientados a la línea".
La "continuación de línea" es una convención en lenguajes orientados a líneas donde el carácter de nueva línea podría malinterpretarse como un terminador de declaración. En tales lenguajes, permite que una sola declaración abarque más de una línea.
Idioma | Separador-terminador de declaraciones | Separador-terminador secundario [1] |
---|---|---|
ABAP | período separado | |
Ada | punto y coma terminado | |
ALGOL | punto y coma separados | |
ALGOL 68 | punto y coma y separados por coma [2] | |
APL | nueva línea terminada | [Direct_function ⋄] Secundario separado |
AppleScript | nueva línea terminada | |
AutoHotkey | nueva línea terminada | |
BÁSICO | nueva línea terminada | colon separado |
Abucheo | nueva línea terminada | |
C | punto y coma termina declaraciones | coma separa expresiones |
C ++ | punto y coma termina declaraciones | coma separa expresiones |
C# | punto y coma terminado | |
COBOL | separados por espacios en blanco, a veces separados por puntos, opcionalmente separados por comas y punto y coma. | |
Cobra | nueva línea terminada | |
CoffeeScript | nueva línea terminada | |
CSS | punto y coma separados | |
D | punto y coma terminado | |
Eiffel | nueva línea terminada | punto y coma |
Erlang | colon separados, período terminado | |
F# | nueva línea terminada | punto y coma |
Fortran | nueva línea terminada | punto y coma |
Adelante | el punto y coma terminan las definiciones de palabras. el espacio termina el uso de palabras | |
BÁSICO DE GFA | nueva línea terminada | |
Ir | separado por punto y coma (insertado por el compilador) | |
Haskell (en notación do) | nueva línea separada | |
Haskell (en notación do, cuando se usan llaves) | punto y coma separados | |
Java | punto y coma terminado | |
JavaScript | punto y coma separados (pero a veces insertados implícitamente en nuevas líneas) | |
Kotlin | punto y coma separados (pero a veces insertados implícitamente en nuevas líneas) | |
Lua | separados por espacios en blanco (punto y coma opcional) | |
Mathematica también llamado Wolfram | punto y coma separados | |
MATLAB | nueva línea terminada | punto y coma o coma [3] |
MUMPS también llamado M | newline termina el alcance de línea, lo más cercano a una "declaración" que M tiene. | un espacio separa / termina un comando, permitiendo que otro comando lo siga. |
Nim | nueva línea terminada | |
Object Pascal también ( Delphi ) | punto y coma separados | |
C objetivo | punto y coma terminado | |
OCaml | punto y coma separados | |
Pascal | punto y coma separados | |
Perl | punto y coma separados | |
PHP | punto y coma terminado | |
Elija Básico | nueva línea terminada | punto y coma separados |
Potencia Shell | nueva línea terminada | punto y coma separados |
Prólogo | separados por comas (conjunción), separados por punto y coma (disyunción), punto terminado (cláusula) | |
Pitón | nueva línea terminada | punto y coma |
R | nueva línea terminada [4] | punto y coma [4] |
Raku | punto y coma separados | |
rojo | espacios en blanco separados | |
Rubí | nueva línea terminada | punto y coma |
Oxido | punto y coma termina declaraciones | coma separa expresiones |
Scala | nueva línea terminada (punto y coma opcional) | punto y coma |
Semilla7 | separados por punto y coma (se permite la terminación por punto y coma) | |
Simula | punto y coma separados | |
Jerga | punto y coma separados | |
Charla | período separado | |
ML estándar | punto y coma separados | |
Rápido | separado por punto y coma (insertado por el compilador) | |
Visual Basic | nueva línea terminada | colon separado |
Visual Basic .NET | nueva línea terminada | colon separado |
Wolfram Language | punto y coma separados | |
Xojo | nueva línea terminada | |
Idioma | Separador-terminador de declaraciones | Separador-terminador secundario [1] |
Continuación de línea
La continuación de la línea se realiza generalmente como parte del análisis léxico : una nueva línea normalmente da como resultado que se agregue un token al flujo de tokens, a menos que se detecte la continuación de la línea.
- Espacio en blanco : idiomas que no necesitan continuaciones
- Ada : las líneas terminan con punto y coma
- C # : las líneas terminan con punto y coma
- JavaScript : las líneas terminan con punto y coma (que se puede inferir)
- Lua
- OCaml
- Ampersand como último carácter de la línea
- Fortran 90 , Fortran 95 , Fortran 2003 , Fortran 2008
- Barra invertida como último carácter de la línea
- bash [5] y otras shells de Unix
- C y C ++ preprocesador
- Mathematica y Wolfram Language
- Python [6]
- Rubí
- JavaScript : solo dentro de cadenas entre comillas simples o dobles
- Marque atrás como último carácter de la línea
- Potencia Shell
- Guión como último carácter de la línea
- SQL * Plus
- Subrayar como último carácter de la línea
- AutoIt
- Cobra
- Visual Basic
- Xojo
- Puntos suspensivos (como tres puntos, no un carácter especial)
- MATLAB : No es necesario que el token de puntos suspensivos sea el último carácter de la línea, pero se ignorarán los siguientes. [7] (En esencia, comienza un comentario que se extiende hasta (es decir, incluye) el primer carácter de nueva línea posterior. Compare esto con un comentario en línea, que se extiende hasta la primera línea nueva).
- Delimitador de coma como último carácter de la línea
- Ruby (el comentario puede seguir al delimitador)
- Delimitador de corchete izquierdo como último carácter de la línea
- Archivo por lotes : iniciar un bloque entre paréntesis puede permitir la continuación de la línea [8]
- Ruby: paréntesis izquierdo, corchete izquierdo o corchete izquierdo
- Operador como último objeto de la línea
- Ruby (el comentario puede seguir al operador)
- Operador como primer carácter de la línea continua
- AutoHotkey : cualquier operador de expresión excepto ++ y -, así como una coma o un punto [9]
- Barra invertida como primer carácter de la línea continua
- Vimscript
- Alguna forma de comentario en línea sirve como continuación de línea
- Ensamblador turbo :
\
- m4 :
dnl
- TeX :
%
- Posición del personaje
- Fortran 77 : Una línea sin comentarios es una continuación de la línea anterior sin comentarios si aparece algún carácter sin espacio en la columna 6. Las líneas de comentarios no pueden continuar.
- COBOL : Las constantes de cadena pueden continuar sin terminar la cadena original en una cláusula PICTURE con
'
, luego insertando a-
en la columna 7 (*
se usa la misma posición que el comentario for). - TUTOR : Las líneas que comienzan con una tabulación (después de cualquier sangría requerida por el contexto) continúan el comando anterior.
- [Fin y comienzo] con comillas normales
- Preprocesador de C y C ++ : la cadena finaliza normalmente y continúa comenzando con una cita en la siguiente línea.
Bibliotecas
Para importar una biblioteca es una manera de leer posiblemente compilados, rutinas, programas o paquetes externos,. Las importaciones se pueden clasificar por nivel (módulo, paquete, clase, procedimiento, ...) y por sintaxis (nombre de directiva, atributos, ...)
- Importación de archivos
addpath(directory)
MATLAB [10]COPY filename.
COBOL:-include("filename").
Prólogo#include file="filename"
ÁSPID#include "filename"
, AutoHotkey , AutoIt , C , C ++#include <filename>
AutoHotkey , AutoIt , C , C ++#import "filename"
, Objetivo-C#import <filename>
C objetivoImport["filename"]
Mathematica y Wolfram Languageinclude 'filename'
Fortraninclude "filename";
PHPinclude [filename] program
, Elija Básico#include [filename] program
Elija Básicoinclude!( "filename");
Oxidoload "filename"
Halcónload %filename
rojorequire("filename")
Luarequire "filename";
Perl , PHPsource(""filename"")
R
- Importación de paquetes
#include filename
C , C ++#[path = "filename"] mod altname;
, Óxido@import module;
C objetivo<<name
Mathematica y Wolfram Language:-use_module(module).
Prólogo :from module import *
Pitónextern crate libname;
, Óxidoextern crate libname as altname;
Oxidomod modname;
, Óxidolibrary("package")
R :load module
, Halcónload module.submodule
HalcónIMPORT module
Oberonimport altname "package/name"
Ir :import package.module;
, Dimport altname = package.module;
Dimport Module
, Haskellimport qualified Module as M
Haskellimport package.*
Java , MATLAB , kotlinimport "modname";
JavaScript :import altname from "modname";
, JavaScript :import package
Scalaimport package._
, Scalaimport module
Rápidoimport module
, Pythonrequire("modname")
Lua :use module
, Fortran 90 +use module, only : identifier
Fortran 90 +use Module;
, Perluse Module qw(import options);
Perluse Package.Name
Cobrauses unit
Pascalwith package
Ada
- Importación de clases
from module import class
Pitónimport class
Halcónimport package.class
Java , MATLAB , kotlinimport class from "modname";
, JavaScriptimport {class} from "modname";
, JavaScriptimport {class as altname} from "modname";
JavaScriptimport package.class
, Scalaimport package.{ class1 => alternativeName, class2 }
, Scalaimport package._
Scalause Namespace\ClassName;
, PHPuse Namespace\ClassName as AliasName;
PHP
- Importación de procedimiento / función
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;
, Óxido :use module::submodule::{symbol1, symbol2};
, Óxido :use module::submodule::symbol as altname;
Óxido :
- Importación constante
use const Namespace\CONST_NAME;
PHP
Las declaraciones anteriores también pueden clasificarse por si son una conveniencia sintáctica (permitiendo que las cosas se mencionen con un nombre más corto, pero aún así se puede hacer referencia a ellas con un nombre completamente calificado sin importar), o si realmente se requieren para acceder el código (sin el cual es imposible acceder al código, incluso con nombres completos).
- Conveniencia sintáctica
import package.*
Javaimport package.class
Javaopen module
OCaml
- Requerido para acceder al código
import altname "package/name"
Irimport altname from "modname";
JavaScriptimport module
Pitón
Bloques
Un bloque es una notación para un grupo de dos o más declaraciones, expresiones u otras unidades de código que están relacionadas de tal manera que comprenden un todo.
- Llaves (también conocidas como llaves)
{
...}
- Lenguajes de programación de corchetes : C , C ++ , Objective-C , Go , Java , JavaScript / ECMAScript , C # , D , Perl , PHP (
for
&loop
bucles, o pasar un bloque como argumento), R , Rust , Scala , S-Lang , Swift , Windows PowerShell , Haskell (en notación), AutoHotkey
- Paréntesis
(
...)
- OCaml , Prolog , ML estándar
- Corchetes
[
...]
- Smalltalk (los bloques son objetos de primera clase, también conocidos como cierres)
begin
...end
- Ada , ALGOL , Pascal , Ruby (
for
,do/while
&do/until
loops), OCaml , SCL , Simula , Erlang .
do
...end
- PL / I , REXX
do
...done
- Bash (
for
&while
bucles), Visual Basic , Fortran , TUTOR (con sangría obligatoria del cuerpo del bloque), Visual Prolog
do
...end
- Lua , Ruby (pasa bloques como argumentos,
for
bucle), Seed7 (encierra cuerpos de bucle entredo
yend
)
- X ...
end
(pif
. Ej. ...end
):
- Rubí (
if
,while
,until
,def
,class
,module
declaraciones), OCaml (for
ywhile
bucles), MATLAB (if
yswitch
condicionales,for
ywhile
bucles,try
cláusula,package
,classdef
,properties
,methods
,events
, yfunction
bloques), Lua (then
/else
yfunction
)
- (
begin
...)
- Esquema
- (progn ...)
- Ceceo
- (
do
...)
- Clojure
- Sangría
- Lenguajes de reglas externos : Cobra , CoffeeScript , F # , Haskell (en notación do cuando se omiten las llaves), occam , Python , Nim
- Lenguajes de forma libre : la mayoría de los descendientes de ALGOL (incluidos C , Pascal y Perl ); Lenguajes Lisp
- Otros
- Ada , Visual Basic , Seed7 :
if
...end if
- APL :
:If
...:EndIf
o:If
...:End
- Bash , sh y 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 declaraciones; ....
para oraciones. - Visual Basic .Net :
If
...End If
,For
...Next
,Do
...Loop
- Pequeño Básico :
If
...EndIf
,For
...EndFor
,While
...EndWhile
Comentarios
Los comentarios se pueden clasificar por:
- estilo (en línea / bloque)
- analizar reglas (ignoradas / interpoladas / almacenadas en la memoria)
- recursividad (encajable / no encajable)
- usos ( cadenas de documentación / comentarios desechables / otros)
Comentarios en línea
Los comentarios en línea son generalmente aquellos que usan un carácter de nueva línea para indicar el final de un comentario y un delimitador arbitrario o secuencia de tokens para indicar el comienzo de un comentario.
Ejemplos:
Símbolo | Idiomas |
---|---|
C | Fortran I a Fortran 77 (C en la columna 1) |
REM | BÁSICO , archivos por lotes |
:: | Archivos por lotes , COMMAND.COM , cmd.exe |
NB. | J ; de la abreviatura común (históricamente) Nota bene , el latín para "nota bien". |
⍝ | APL ; la mnemotécnica es el glifo (jota sobrecargada con calzado) se asemeja a una lámpara de escritorio y, por tanto, "ilumina" lo anterior. |
# | Shell Bourne y otros shells UNIX , Cobra , Perl , Python , Ruby , Seed7 , Windows PowerShell , PHP , R , Make , Maple , Elixir , Nim [11] |
% | TeX , Prolog , MATLAB , [12] 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 |
' | Mono, Visual Basic , VBScript , Small Basic , Gambas , Xojo |
! | Fortran , Basic Plus, Informar, Elegir básico |
; | Ensamblaje x86 , AutoHotkey , AutoIt , Lisp , Common Lisp , Clojure , Rebol , Red , Scheme |
-- | Euforia , Haskell , SQL , Ada , AppleScript , Eiffel , Lua , VHDL , SGML , PureScript |
* | Ensamblador S / 360 (* en la columna 1), COBOL I a COBOL 85, PAW , Fortran IV a Fortran 77 (* en la columna 1), Pick Basic , GAMS (* en la columna 1) |
|| | Rizo |
" | Vimscript , ABAP |
\ | Adelante |
*> | COBOL 90 |
Bloquear comentarios
Los comentarios de bloque son generalmente aquellos que usan un delimitador para indicar el comienzo de un comentario y otro delimitador para indicar el final de un comentario. En este contexto, los espacios en blanco y los caracteres de nueva línea no se cuentan como delimitadores.
Ejemplos:
Símbolo | Idiomas |
---|---|
comment ~ ; | ALGOL 60 , SIMULA |
¢ ~ ¢ , # ~ # , co ~ co , comment ~comment | ALGOL 68 [13] [14] |
/* ~ */ | ActionScript, AutoHotkey , C, C ++, C #, D, [15] Go, Java , JavaScript , kotlin , Objective-C , PHP , PL / I , Prolog , Rexx , Rust (se puede anidar), Scala (se puede anidar) , SAS , SASS, SQL, Swift (se puede anidar), Visual Prolog , CSS |
#cs ~ #ce | AutoIt [16] |
/+ ~ +/ | D (se puede anidar) [15] |
/# ~ #/ | Cobra (se puede anidar) |
<# ~ #> | Potencia Shell |
| HTML , XML |
=begin ~ =cut | Perl |
#`( ~ ) | Raku (los caracteres entre corchetes pueden ser (), <>, {}, [], cualquier carácter Unicode con reflejos BiDi o caracteres Unicode con propiedades Ps / Pe / Pi / Pf) |
=begin ~ =end | Rubí |
#<TAG> ~ , ~ , ~ , ~ , ~ , ~#TAG> #stop EOF #iffalse #endif #ifntrue #endif #if false #endif #if !true #endif | S-Lang [17] |
{- ~ -} | Haskell (se puede anidar) |
(* ~ *) | Delphi , ML, Mathematica, Object Pascal, Pascal , Seed7 , Applescript , OCaml (se puede anidar), ML estándar (se puede anidar), Maple, Newspeak , F # |
{ ~ } | Delphi, Object Pascal, Pascal, Rojo |
{# ~ #} | Nunjucks, Ramita |
{{! ~ }} | Bigote , Manillar |
{{!-- ~ --}} | Manillares (no se pueden anidar, pero pueden contener {{ y }} ) |
|# ~ #| | Rizo |
%{ ~ %} | MATLAB [12] (los símbolos deben estar en una línea separada) |
#| ~ |# | Lisp , Scheme , Racket (se puede anidar en los tres). |
#[ ~ ]# | Nim [18] |
--[[ ~ ]] , --[=[ ~ ]=] , --[= ... =[ ~ ]= ...=] | Lua (los corchetes pueden tener cualquier número de caracteres = coincidentes; se pueden anidar dentro de delimitadores que no coinciden) |
" ~ " | Charla |
(comment ~ ) | Clojure |
Variantes únicas
- Fortran
- Las líneas de sangría en Fortran 66/77 son significativas. La declaración real está en las columnas 7 a la 72 de una línea. Cualquier carácter que no sea un espacio en la columna 6 indica que esta línea es una continuación de la línea anterior. A '
C
' en la columna 1 indica que toda esta línea es un comentario. Las columnas 1 a 5 pueden contener un número que sirve como etiqueta. Las columnas 73 a 80 se ignoran y pueden usarse para comentarios; en los días de las tarjetas perforadas , estas columnas a menudo contenían un número de secuencia para que la baraja de cartas pudiera clasificarse en el orden correcto si alguien accidentalmente dejaba caer las cartas. Fortran 90 eliminó la necesidad de la regla de sangría y agregó comentarios en línea, utilizando el!
carácter como delimitador de comentarios.
- COBOL
- En el código de formato fijo, la sangría de la línea es significativa. Las columnas 1 a 6 y las columnas de la 73 en adelante se ignoran. Si hay una
*
o/
en la columna 7, esa línea es un comentario. Hasta COBOL 2002, si unD
od
estaba en la columna 7, definiría una "línea de depuración" que se ignoraría a menos que el compilador tuviera instrucciones de compilarlo.
- Cobra
- Cobra admite comentarios de bloque con "
/#
...#/
", que es como el "/*
...*/
" que se encuentra a menudo en los lenguajes basados en C, pero con dos diferencias. El#
carácter se reutiliza desde el formulario de comentarios de una sola línea "#
...", y los comentarios del bloque se pueden anidar, lo que es conveniente para comentar grandes bloques de código.
- Rizo
- Curl admite comentarios de bloque con etiquetas definidas por el usuario como en
|foo# ... #foo|
.
- Lua
- Al igual que las cadenas sin formato, puede haber cualquier número de signos iguales entre los corchetes, siempre que las etiquetas de apertura y cierre tengan un número coincidente de signos iguales; esto permite la anidación, siempre y cuando los comentarios de bloques anidados / cuerdas primas utilizan un número diferente de signos de igual que su comentario encierra:
--[[comment --[=[ nested comment ]=] ]]
. Lua descarta la primera nueva línea (si está presente) que sigue directamente a la etiqueta de apertura.
- Perl
- Los comentarios de bloque en Perl se consideran parte de la documentación y se les da el nombre Plain Old Documentation (POD). Técnicamente, Perl no tiene una convención para incluir comentarios de bloque en el código fuente, pero POD se usa habitualmente como solución.
- PHP
- PHP admite comentarios de estilo C / C ++ estándar, pero también admite el estilo Perl.
- Pitón
- El uso de comillas triples para comentar líneas de fuente, en realidad no forma un comentario. [19] El texto adjunto se convierte en un literal de cadena, que Python generalmente ignora (excepto cuando es la primera declaración en el cuerpo de un módulo, clase o función; ver docstring ).
- Raku
- Raku utiliza
#`(...)
para denotar comentarios en bloque. [20] Raku en realidad permite el uso de cualquier "derecha" e "izquierda" emparejado paréntesis después#`
(es decir#`(...)
,#`[...]
,#`{...}
,#`<...>
, e incluso el más complicado#`{{...}}
son todos los comentarios bloque válido). Los corchetes también se pueden anidar dentro de los comentarios (es decir,#`{ a { b } c }
van a la última llave de cierre).
- Rubí
- El comentario de bloque en Ruby se abre en la
=begin
línea y se cierra en la=end
línea.
- Jerga
- El intérprete ignora la región de líneas encerradas por los delimitadores
#
y#
. El nombre de la etiqueta puede ser cualquier secuencia de caracteres alfanuméricos que se pueden utilizar para indicar cómo se descifrará el bloque adjunto. Por ejemplo,#
podría indicar el inicio de un bloque de documentación con formato LaTeX.
- Esquema y raqueta
- Se puede comentar con el siguiente componente sintáctico completo (expresión-s)
#;
.
- ABAP
ABAP admite dos tipos diferentes de comentarios. Si el primer carácter de una línea, incluida la sangría, es un asterisco ( *
), toda la línea se considera un comentario, mientras que una sola comilla doble ( "
) comienza una commet en línea que actúa hasta el final de la línea. Los comentarios ABAP no son posibles entre las declaraciones EXEC SQL
y ENDEXEC
porque Native SQL tiene otros usos para estos caracteres. En la mayoría de los dialectos SQL, --
se puede usar el guión doble ( ) en su lugar.
- Lenguas esotéricas
- Muchos lenguajes de programación esotéricos siguen la convención de que cualquier texto que no se ejecute con el puntero de instrucción (por ejemplo, Befunge ) o que no se le asigne un significado (por ejemplo, Brainfuck ), se considera un "comentario".
Comparación de comentarios
Existe una amplia variedad de estilos de sintaxis para declarar comentarios en el código fuente. BlockComment
en cursiva se utiliza aquí para indicar el estilo de comentario de bloque. InlineComment
en cursiva se utiliza aquí para indicar el estilo de comentario en línea.
Idioma | Comentario en línea | Bloquear comentario |
---|---|---|
Ada , Eiffel , Euphoria , Occam , SPARK , ANSI SQL y VHDL | -- InlineComment | |
ALGOL 60 | comment BlockComment; | |
ALGOL 68 | ¢ BlockComment ¢
| |
APL | ⍝ InlineComment | |
AppleScript | -- InlineComment | (* BlockComment *) |
Lenguaje ensamblador (varía) | ; InlineComment un ejemplo (la mayoría de los lenguajes ensambladores usan solo comentarios de línea) | |
AutoHotkey | ; InlineComment | /* BlockComment */ |
AWK , Bash , Bourne shell , C shell , Maple , R , Tcl y Windows PowerShell | # InlineComment | <# BlockComment #> |
BÁSICO (varios dialectos): | 'InlineComment (no todos los dialectos)
| |
C (K&R, ANSI / C89 / C90), CHILL , PL / I y REXX | /* BlockComment */ | |
C (C99) , C ++ , Go , Swift y JavaScript | // InlineComment | /* BlockComment */ |
C# | // InlineComment /// InlineComment (Comentario de documentación XML) | /* BlockComment */ /** BlockComment */ (Comentario de documentación XML) |
COBOL I a COBOL 85 | * InlineComment (* en la columna 7) | |
COBOL 2002 | *> InlineComment | |
Rizo | || InlineComment | |# BlockComment #|
|
Cobra | # InlineComment | /# BlockComment #/ (encajable) |
D | // InlineComment /// Documentation InlineComment ( comentarios de ddoc ) | /* BlockComment */ /** Documentation BlockComment */ ( comentarios de ddoc )
|
DCL | $! InlineComment | |
ECMAScript ( JavaScript , ActionScript , etc.) | // InlineComment | /* BlockComment */ |
Adelante | \ InlineComment | ( BlockComment ) (línea única y multilínea)
|
FORTRAN I a FORTRAN 77 | C InlineComment (C en la columna 1) | |
Fortran 90 | ! InlineComment | |
Haskell | -- InlineComment | {- BlockComment -} |
Java | // InlineComment | /* BlockComment */
|
Lisp y Scheme | ; InlineComment | #| BlockComment |# |
Lua | -- InlineComment | --[==[ BlockComment]==] (número variable de = signos) |
Arce | # InlineComment | (* BlockComment *) |
Mathematica | (* BlockComment *) | |
Matlab | % InlineComment | %{ Nota: Ambos símbolos de corchetes de porcentaje deben ser los únicos caracteres que no sean espacios en blanco en sus respectivas líneas. |
Nim | # InlineComment | #[ BlockComment ]# |
Objeto Pascal (Delphi) | // InlineComment | (* BlockComment *) { BlockComment } |
OCaml | (* BlockComment (* nestable *) *) | |
Pascal , Modula-2 , Modula-3 , Oberon y ML : | (* BlockComment *) | |
Perl y Ruby | # InlineComment | =begin ( =end en Ruby) ( comentario de documentación de POD )
|
PHP | # InlineComment // InlineComment | /* BlockComment */ /** Documentation BlockComment */ ( Comentarios de PHP Doc ) |
PILOTO | R:InlineComment | |
PLZ / SYS | ! BlockComment ! | |
PL / SQL y TSQL | -- InlineComment | /* BlockComment */ |
Prólogo | % InlineComment | /* BlockComment */ |
Pitón | # InlineComment | ''' BlockComment ''' ( Cadena de documentación en la primera línea del módulo, clase, método o función) |
R | # InlineComment | |
Raku | # InlineComment | #`{
|
rojo | ; InlineComment | { BlockComment } |
Oxido | // InlineComment
| /* BlockComment */ (encajable)
|
SAS | * BlockComment; /* BlockComment */ | |
Semilla7 | # InlineComment | (* BlockComment *) |
Simula | comment BlockComment; ! BlockComment; | |
Charla | "BlockComment" | |
Sabelotodo | {* BlockComment *} | |
ML estándar | (* BlockComment *) | |
TeX , LaTeX , PostScript , Erlang , Elixir y S-Lang | % InlineComment | |
Texinfo | @c InlineComment
| |
TUTOR | * InlineComment command $$ InlineComment | |
Visual Basic | ' InlineComment Rem InlineComment | |
Visual Basic .NET | ' InlineComment
| |
Prólogo visual | % InlineComment | /* BlockComment */ |
Wolfram Language | (* BlockComment *) | |
Xojo | ' InlineComment // InlineComment rem InlineComment |
Ver también
- Sintaxis C
- Sintaxis de C ++
- Lenguajes de programación de corchetes , una amplia familia de sintaxis de lenguajes de programación
- Sintaxis de Java
- Sintaxis de JavaScript
- Sintaxis y semántica de PHP
- Sintaxis y semántica de Python
Referencias
- ^ a b Para múltiples declaraciones en una línea
- ^ Tres tipos diferentes de cláusulas, cada una separa las frases y las unidades de manera diferente:
- cláusula-serial usando go-on-token (es decir, punto y coma): comience a; B; c end : las unidades se ejecutan en orden.
- cláusula-colateral usando y-también-token (es decir, ","): begin a, b, c end - el compilador debe optimizar el orden de ejecución.
- cláusula-paralela usando y-también-token (es decir, ","): par begin a, b, c end - las unidades deben ejecutarse en subprocesos paralelos.
- ^ punto y coma: resultado de la declaración que retrocede oculto, coma: se muestra el resultado
- ^ a b De la definición del lenguaje R , sección 3.2 Estructuras de control: "Un punto y coma siempre indica el final de una declaración, mientras que una nueva línea puede indicar el final de una declaración. Si la declaración actual no es sintácticamente completa, las líneas nuevas simplemente son ignoradas por el evaluador ".
- ^ Manual de referencia de Bash , 3.1.2.1 Carácter de escape
- ^ Documentación de Python , 2. Análisis léxico : 2.1.5. Unión de línea explícita
- ^ Mathworks.com Archivado el 7 de febrero de 2010 en Wayback Machine.
- ^ https://ss64.com/nt/syntax-brackets.html
- ^ https://autohotkey.com/docs/Scripts.htm#continuation
- ^ Para que un archivo M (fuente MATLAB) sea accesible por nombre, su directorio principal debe estar en la ruta de búsqueda (o directorio actual).
- ^ https://nim-lang.org/docs/manual.html#lexical-analysis-comments
- ^ a b "Mathworks.com" . Archivado desde el original el 21 de noviembre de 2013 . Consultado el 25 de junio de 2013 .
- ^ "Algol68_revised_report-AB.pdf en PDF págs. 61–62, documento original págs. 121–122" (PDF) . Consultado el 27 de mayo de 2014 .
- ^ "Versión HTML del informe revisado Algol68 AB" . Archivado desde el original el 17 de marzo de 2013 . Consultado el 27 de mayo de 2014 .
- ^ a b "DLang.org, Lexical" . Consultado el 27 de mayo de 2014 .
- ^ "Referencia de palabras clave de AutoItScript.com, # comments-start" . Consultado el 27 de mayo de 2014 .
- ^ "slang-2.2.4 / src / slprepr.c - línea 43 a 113" . Consultado el 28 de mayo de 2014 .
- ^ "Manual de Nim" .
- ^ "Consejo de Python: puede utilizar cadenas de varias líneas como comentarios de varias líneas" , 11 de septiembre de 2011, Guido van Rossum
- ^ "Documentación de Perl 6 (sintaxis)" . docs.perl6.org. Comentarios . Consultado el 5 de abril de 2017 .
- ^ "Comentarios de Perl 6 POD" .
- ^ "Perl 6 POD (bloques abreviados)" .