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 informática.
Las expresiones del lenguaje de programación se pueden clasificar en cuatro estructuras sintácticas:
(* (+ 2 3) (expt 4 5))
(2 + 3) * (4 ** 5)
2 3 + 4 5 ** *
(2 + 3)(45) $$ note implicit multiply operator
Cuando un lenguaje de programación tiene declaraciones , normalmente tiene convenciones para:
Un separador de sentencias delimita el límite entre dos sentencias independientes. Un terminador de sentencias define el final de una sentencia individual. Los lenguajes que interpretan el final de una línea como el final de una sentencia se denominan lenguajes "orientados a la línea".
La "continuación de línea" es una convención en los lenguajes orientados a líneas en la que el carácter de nueva línea podría ser malinterpretado como un finalizador de sentencia. En dichos lenguajes, permite que una sola sentencia ocupe más de una línea.
La continuación de línea generalmente se realiza 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 una continuación de línea.
\
dnl
%
'
, y luego insertamos un -
en la columna 7 ( *
se usa la misma posición que el comentario for).Importar una biblioteca es una forma de leer rutinas, programas o paquetes externos, posiblemente compilados. Las importaciones se pueden clasificar por nivel (módulo, paquete, clase, procedimiento,...) y por sintaxis (nombre de directiva, atributos,... )
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>
Objetivo-CImport["filename"]
Mathematica , lenguaje Wolframinclude 'filename'
Fortraninclude "filename";
PHPinclude [filename] program
, Seleccione Básico#include [filename] program
Seleccione Básicoinclude!("filename");
Óxidoload "filename"
Rubíload %filename
Rojorequire('filename')
Luarequire "filename";
Perl , PHPrequire "filename"
Rubísource(""filename"")
R@import("filename");
Zig#include filename
C , C++#[path = "filename"] mod altname;
, Óxido@import module;
Objetivo-C<<name
Mathematica , lenguaje Wolfram:-use_module(module).
Prólogo :from module import *
Pitónextern crate libname;
, Óxidoextern crate libname as altname;
Óxidomod modname;
, Óxidolibrary("package")
R :IMPORT module
Oberónimport 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
Escalaimport package._
, Escalaimport module
Rápidoimport module
V (lenguaje)import module
, Pitónrequire "gem"
, Rubíuse module
, Fortran 90+use module, only : identifier
Fortran 90+use Module;
Perlause Module qw(import options);
Perluse Package.Name
Cobrauses unit
Pascalwith package
Ada@import("pkgname");
Zigfrom module import Class
Pitónimport package.class
Java , MATLAB , Kotlinimport class from "modname";
, JavaScriptimport {class} from "modname";
, JavaScriptimport {class as altname} from "modname";
JavaScriptimport package.class
, Escalaimport package.{ class1 => alternativeName, class2 }
, Escalaimport package._
Escalause Namespace\ClassName;
, PHPuse Namespace\ClassName as AliasName;
PHPfrom module import function
Pitón :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
, Escala :import package.class.{ function => alternativeName, otherFunction }
Escala :use Module ('symbol');
Perla :use function Namespace\function_name;
, PHP :use Namespace\function_name as function_alias_name;
Programa PHP :use module::submodule::symbol;
, Óxido :use module::submodule::{symbol1, symbol2};
, Óxido :use module::submodule::symbol as altname;
Óxido :use const Namespace\CONST_NAME;
PHPLas afirmaciones anteriores también se pueden clasificar según sean una conveniencia sintáctica (que permite hacer referencia a las cosas con un nombre más corto, pero aún así se puede hacer referencia a ellas con algún nombre completamente calificado sin importancia) o según sean realmente necesarias para acceder al código (sin lo cual es imposible acceder al código, incluso con nombres completamente calificados).
import package.*
Javaimport package.class
Javaopen module
OCamlimport altname "package/name"
Irimport altname from "modname";
JavaScriptimport module
PitónUn 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 forman un todo.
{
...}
for
& loop
o pasar un bloque como argumento), R , Rust , Scala , S-Lang , Swift , PowerShell , Haskell (en notación do), AutoHotkey , Zig(
...)
[
...]
begin
...end
for
, do/while
& do/until
bucles), OCaml , SCL , Simula , Erlang .do
...end
do
...done
for
& while
), F# (sintaxis detallada) [11] Visual Basic , Fortran , TUTOR (con sangría obligatoria del cuerpo del bloque), Visual Prologdo
...end
for
bucle), Seed7 (encierra los cuerpos del bucle entre do
y end
)end
(por ejemplo if
... end
):if
, while
, until
, def
, class
, module
declaraciones), OCaml ( for
& while
bucles), MATLAB ( if
& switch
condicionales, for
& while
bucles, try
cláusula, package
, classdef
, properties
, methods
, events
, & function
bloques), Lua ( then
/ else
& function
)begin
...)do
...)if
...end if
:If
... :EndIf
o :If
...:End
if
... fi
, do
... done
, case
... esac
;begin
... end
, (
... )
, if
... fi
, do
...od
repeat
...until
IF
... END-IF
, PERFORM
... END-PERFORM
, etc. para declaraciones; ... .
para oraciones.If
... End If
, For
... Next
, Do
...Loop
If
... EndIf
, For
... EndFor
, While
...EndWhile
Los comentarios se pueden clasificar por:
Los comentarios en línea son generalmente aquellos que utilizan un carácter de nueva línea para indicar el final de un comentario y un delimitador arbitrario o una secuencia de tokens para indicar el comienzo de un comentario.
Ejemplos:
Los comentarios en bloque son generalmente aquellos que utilizan 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. En los ejemplos, el símbolo ~ representa el comentario y los símbolos que lo rodean son entendidos por los intérpretes/compiladores como los delimitadores.
Ejemplos:
C
' en la columna 1 indica que esta línea entera 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 se pueden usar para comentarios; en la época de las tarjetas perforadas , estas columnas a menudo contenían un número de secuencia para que la baraja de cartas pudiera ordenarse en el orden correcto si alguien dejaba caer las cartas accidentalmente. 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.*
o /
en la columna 7, entonces esa línea es un comentario. Hasta COBOL 2002, si había un D
o d
en la columna 7, definía una "línea de depuración" que se ignoraba a menos que se le indicara al compilador que lo compilara./#
... #/
", que es similar al " /*
... */
" que se encuentra a menudo en los lenguajes basados en C, pero con dos diferencias. El #
carácter se reutiliza a partir del formato de comentario de una sola línea " #
...", y los comentarios en bloque se pueden anidar, lo que resulta conveniente para comentar grandes bloques de código.|foo# ... #foo|
.--[[comment --[=[ nested comment ]=] ]]
. Lua descarta la primera nueva línea (si está presente) que sigue directamente a la etiqueta de apertura.~S
(que evita la interpolación de cadenas) a la cadena entre comillas triples, lo que lleva a la construcción final ~S""" ... """
. Además, Elixir admite una forma limitada de comentarios en bloque como una característica oficial del lenguaje, pero como en Perl, esta construcción está destinada exclusivamente a escribir documentación. A diferencia de Perl, no se puede utilizar como una solución alternativa, ya que está limitada a ciertas partes del código y arroja errores o incluso suprime funciones si se utiliza en otro lugar. [22]#`(...)
para denotar comentarios en bloque. [23] Raku en realidad permite el uso de cualquier paréntesis "derecho" e "izquierdo" después #`
(es decir #`(...)
, #`[...]
, #`{...}
, #`<...>
, e incluso los más complicados #`{{...}}
son todos comentarios en bloque válidos). También se permite que los corchetes estén anidados dentro de los comentarios (es decir, #`{ a { b } c }
van hasta la última llave de cierre).=begin
la línea y se cierra en =end
la línea.#<tag>
y . El nombre de la etiqueta puede ser cualquier secuencia de caracteres alfanuméricos que se puedan utilizar para indicar cómo se debe descifrar el bloque encerrado. Por ejemplo, podría indicar el comienzo de un bloque de documentación con formato LaTeX.#</tag>
#<latex>
#;
.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 comilla doble simple ( "
) comienza un comentario en línea que actúa hasta el final de la línea. Los comentarios ABAP no son posibles entre las sentencias EXEC SQL
y ENDEXEC
porque SQL nativo tiene otros usos para estos caracteres. En la mayoría de los dialectos SQL, --
se puede utilizar el guión doble ( ) en su lugar.
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 en bloque. InlineComment
en cursiva se utiliza aquí para indicar el estilo de comentario en línea.
/* ... */
, se pueden usar directivas del compilador para imitarlos tal como en VB.NET._
se puede utilizar para extender un comentario de una sola línea a la siguiente línea sin necesidad de escribir '
o REM
de nuevo. Esto se puede hacer hasta 24 veces seguidas.