Comparación de lenguajes de programación (instrucciones básicas)

Este artículo compara una gran cantidad de lenguajes de programación tabulando sus tipos de datos , su sintaxis de expresión , declaración y sentencia , y algunas interfaces comunes del sistema operativo.

Convenciones de este artículo

En general, var , var o var es la forma en que se representan los nombres de las variables u otros valores no literales que el lector debe interpretar. El resto es código literal. Los guillemets ( «y ») encierran secciones opcionales. Tab ↹indica una sangría necesaria (espacio en blanco).

Las tablas no están ordenadas lexicográficamente en forma ascendente por nombre de lenguaje de programación de forma predeterminada, y algunos lenguajes tienen entradas en algunas tablas pero no en otras.

Identificadores de tipo

Números enteros

	8 bits ( bytes )		16 bits ( entero corto )		32 bits		64 bit ( entero largo )		Tamaño de la palabra		Arbitrariamente preciso ( bignum )
	Firmado	No firmado	Firmado	No firmado	Firmado	No firmado	Firmado	No firmado	Firmado	No firmado	Arbitrariamente preciso ( bignum )
Ada ^[1]	`range -27 .. 27 - 1`^[j]	`range 0 .. 28 - 1`^[j] o `mod 28`^[k]	`range -215 .. 215 - 1`^[j]	`range 0 .. 216 - 1`^[j] o `mod 216`^[k]	`range -231 .. 231 - 1`^[j]	`range 0 .. 232 - 1`^[j] o `mod 232`^[k]	`range -263 .. 263 - 1`^[j]	`mod 2**64`^[k]	`Integer`^[j]	`range 0 .. 2**Integer'Size - 1`^[j] o ^[k]`mod Integer'Size`	—
ALGOL 68 (ancho variable)	`short short int`^[do]	—	`short int`^[do]	—	`int`^[do]	—	`long int`^[do]	—	`int`^[do]	—	`long long int`^[a]^[sol]
ALGOL 68 (ancho variable)	`short short int`^[do]	—	`short int`^[do]	—	`int`^[do]	—	`long int`^[do]	—	`bytes`y`bits`		`long long int`^[a]^[sol]
C ( C99 ancho fijo)	`int8_t`	`uint8_t`	`int16_t`	`uint16_t`	`int32_t`	`uint32_t`	`int64_t`	`uint64_t`	`intptr_t`^[do]	`size_t`^[do]	—
C++ ( C++11 de ancho fijo)	`int8_t`	`uint8_t`	`int16_t`	`uint16_t`	`int32_t`	`uint32_t`	`int64_t`	`uint64_t`	`intptr_t`^[do]	`size_t`^[do]
C ( C99 ancho variable)	`signed char`	`unsigned char`	`short`^[do]	`unsigned short`^[do]	`long`^[do]	`unsigned long`^[do]	`long long`^[do]	`unsigned long long`^[do]	`int`^[do]	`unsigned int`^[do]
C++ ( ancho variable de C++11 )	`signed char`	`unsigned char`	`short`^[do]	`unsigned short`^[do]	`long`^[do]	`unsigned long`^[do]	`long long`^[do]	`unsigned long long`^[do]	`int`^[do]	`unsigned int`^[do]
Objetivo-C ( Cacao )	`signed char`o`int8_t`	`unsigned char`o`uint8_t`	`short`o`int16_t`	`unsigned short`o`uint16_t`	`int`o`int32_t`	`unsigned int`o`uint32_t`	`long long`o`int64_t`	`unsigned long long`o`uint64_t`	`NSInteger`o`long`	`NSUInteger`o`unsigned long`
DO#	`sbyte`	`byte`	`short`	`ushort`	`int`	`uint`	`long`	`ulong`	`IntPtr`	`UIntPtr`	`System.Numerics.BigInteger` (.NET 4.0)
Java	`byte`	—	`short`	`char`^[b]	`int`	—	`long`	—	—	—	`java.math.BigInteger`
Ir	`int8`	`uint8`o`byte`	`int16`	`uint16`	`int32`	`uint32`	`int64`	`uint64`	`int`	`uint`	`big.Int`
Óxido	`i8`	`u8`	`i16`	`u16`	`i32`	`u32`	`i64`	`u64`	`isize`	`usize`	—
Rápido	`Int8`	`UInt8`	`Int16`	`UInt16`	`Int32`	`UInt32`	`Int64`	`UInt64`	`Int`	`UInt`
D	`byte`	`ubyte`	`short`	`ushort`	`int`	`uint`	`long`	`ulong`	—	—	`BigInt`
Lisp común ^[2]	`(signed-byte 8)`	`(unsigned-byte 8)`	`(signed-byte 16)`	`(unsigned-byte 16)`	`(signed-byte 32)`	`(unsigned-byte 32)`	`(signed-byte 64)`	`(unsigned-byte 64)`			`bignum`
Esquema
ISLISP ^[3]											`bignum`
Pascal ( FPC )	`shortint`	`byte`	`smallint`	`word`	`longint`	`longword`	`int64`	`qword`	`integer`	`cardinal`	—
Visual Basic	—	`Byte`	`Integer`	—	`Long`	—	—		—		—
Visual Basic .NET	`SByte`	`Byte`	`Short`	`UShort`	`Integer`	`UInteger`	`Long`	`ULong`	—		`System.Numerics.BigInteger` (.NET 4.0)
Libre básico	`Byte`o`Integer<8>`	`UByte`o`UInteger<8>`	`Short`o`Integer<16>`	`UShort`o`UInteger<16>`	`Long`o`Integer<32>`	`ULong`o`UInteger<32>`	`LongInt`o`Integer<64>`	`ULongInt`o`UInteger<64>`	`Integer`	`UInteger`	—
Python 2.x	—		—		—		—		`int`	—	`long`
Python 3.x	—		—		—		—		—		`int`
Jerga	—		—		—		—		—		—
Fortran	`INTEGER(KIND = n)`^[F]	—	`INTEGER(KIND = n)`^[F]	—	`INTEGER(KIND = n)`^[F]	—	`INTEGER(KIND = n)`^[F]	—
PHP	—		—		`int`^[metro]	—	`int`^[metro]	—	—		^[mi]
Perl 5	- ^[d]		- ^[d]		- ^[d]		- ^[d]		- ^[d]		`Math::BigInt`
Raku	`int8`	`uint8`	`int16`	`uint16`	`int32`	`uint32`	`int64`	`uint64`	`Int`	—
Rubí	—		—		—		—		`Fixnum`	—	`Bignum`
Erlang ^[n]	—		—		—		—		`integer()`	—	`integer()`^[el]
Escala	`Byte`	—	`Short`	`Char`^[l]	`Int`	—	`Long`	—	—	—	`scala.math.BigInt`
Semilla7	—	—	—	—	—	—	`integer`	—	—	—	`bigInteger`
Charla informal	—		—		—		—		`SmallInteger`^[i]	—	`LargeInteger`^[i]
Windows PowerShell	—		—		—		—		—		—
OCaml	—		—		`int32`	—	`int64`	—	`int`o`nativeint`		`open Big_int;;`o`big_int`
F#	`sbyte`	`byte`	`int16`	`uint16`	`int32`o`int`	`uint32`	`int64`	`uint64`	`nativeint`	`unativeint`	`bigint`
ML estándar	—	`Word8.word`	—		`Int32.int`	`Word32.word`	`Int64.int`	`Word64.word`	`int`	`word`	`LargeInt.int`o `IntInf.int`
Haskell ( GHC )	`«import Int»`o`Int8`	`«import Word»`o`Word8`	`«import Int»`o`Int16`	`«import Word»`o`Word16`	`«import Int»`o`Int32`	`«import Word»`o`Word32`	`«import Int»`o`Int64`	`«import Word»`o`Word64`	`Int`	`«import Word»`o`Word`	`Integer`
Torre Eiffel	`INTEGER_8`	`NATURAL_8`	`INTEGER_16`	`NATURAL_16`	`INTEGER_32`	`NATURAL_32`	`INTEGER_64`	`NATURAL_64`	`INTEGER`	`NATURAL`	—
COBOL ^[h]	`BINARY-CHAR «SIGNED»`	`BINARY-CHAR UNSIGNED`	`BINARY-SHORT «SIGNED»`	`BINARY-SHORT UNSIGNED`	`BINARY-LONG «SIGNED»`	`BINARY-LONG UNSIGNED`	`BINARY-DOUBLE «SIGNED»`	`BINARY-DOUBLE UNSIGNED`	—	—	—
Matemática	—		—		—		—		—		`Integer`
Lenguaje Wolfram	—		—		—		—		—		`Integer`

^a Lasconstantes estándarint shorts yint lengthsse pueden usar para determinar cuántasshorts ylongs se pueden anteponer de manera útil ashort intylong int. Los tamaños reales deshort int,int, ylong intestán disponibles como constantesshort max int,max int, ylong max intetc.
^b Se utiliza comúnmente para caracteres.
^c Los lenguajes ALGOL 68, C y C++ no especifican el ancho exacto de los tipos enterosshort,int,long, y ( C99 , C++11 )long long, por lo que dependen de la implementación. En C y C++short,long, ylong longtengan al menos 16, 32 y 64 bits de ancho, respectivamente, pero pueden tener más.intSe requiere que el tipo tenga al menos el mismo ancho queshorty como máximo el mismo ancho quelong, y normalmente es el ancho del tamaño de palabra en el procesador de la máquina (es decir, en una máquina de 32 bits suele tener 32 bits de ancho; en máquinas de 64 bits a veces tiene 64 bits de ancho). C99 y C++11 ^{[ cita requerida ]} también definen los[u]intN_ttipos de ancho exacto en elencabezado stdint.h . Consulte Sintaxis de C#Tipos integrales para obtener más información. Además, los tipossize_typtrdiff_tse definen en relación con el tamaño de la dirección para contener números enteros con y sin signo suficientemente grandes para manejar índices de matriz y la diferencia entre punteros.
^d Perl 5 no tiene tipos diferenciados. Los números enteros, los números de punto flotante, las cadenas, etc. se consideran "escalares".
^e PHP tiene dos bibliotecas de precisión arbitraria. La biblioteca BCMath solo utiliza cadenas como tipo de datos. La biblioteca GMP utiliza un tipo de "recurso" interno.
^f El valor denlo proporciona laSELECTED_INT_KIND^{función intrínseca [4]} .
La opción de tiempo de ejecución de ALGOL 68 G--precision "number"puede establecer la precisión delong long ints en el "número" de dígitos significativos requeridos. Lasconstantes estándarlong long int width ylong long max intse pueden utilizar para determinar la precisión real.
^h COBOL permite especificar una precisión requerida y seleccionará automáticamente un tipo disponible capaz de representar la precisión especificada. "PIC S9999", por ejemplo, requeriría una variable con signo de precisión de cuatro dígitos decimales. Si se especifica como un campo binario, se seleccionaría un tipo con signo de 16 bits en la mayoría de las plataformas.
^i Smalltalk elige automáticamente una representación adecuada para los números integrales. Normalmente, hay dos representaciones: una para los números enteros que se ajustan al tamaño de la palabra nativa menos cualquier bit de etiqueta ( SmallInteger ) y otra que admite números enteros de tamaño arbitrario ( LargeInteger ). Las operaciones aritméticas admiten argumentos polimórficos y devuelven el resultado en la representación compacta más adecuada.
^j Los tipos de rango de Ada se comprueban en tiempo de ejecución (así como en tiempo de compilación para expresiones estáticas) para detectar violaciones de límites. Las violaciones de límites en tiempo de ejecución generan una excepción de "error de restricción". Los rangos no están restringidos a potencias de dos. Los subtipos de enteros comúnmente predefinidos son: Positive (range 1 .. Integer'Last) y Natural (range 0 .. Integer'Last).Short_Short_Integer(8 bits),Short_Integer(16 bits) yLong_Integer(64 bits) también suelen estar predefinidos, pero no son requeridos por el estándar de Ada. Las comprobaciones en tiempo de ejecución se pueden deshabilitar si el rendimiento es más importante que las comprobaciones de integridad.
^k Los tipos de módulo de Ada implementan la aritmética de módulo en todas las operaciones, es decir, no es posible violar ningún rango. Los módulos no están restringidos a potencias de dos.
^l Se utiliza comúnmente para caracteres como char de Java.
^m int en PHP tiene el mismo ancho quelongel tipo en C en ese sistema.^[c]
^n Erlang tiene tipado dinámico. Los identificadores de tipo se utilizan normalmente para especificar los tipos de campos de registro y los tipos de argumentos y de retorno de las funciones.^[5]
^o Cuando excede de una palabra.^[6]

Punto flotante

	Precisión simple	Doble precisión	Otra precisión	Depende del procesador
Ada ^[1]	`Float`	`Long_Float`	—
ALGOL 68	`real`^[a]	`long real`^[a]	`short real`, `long long real`, etc. ^[d]
do	`float`^[b]	`double`	`long double`^[F]
C++ (STL)
Objetivo-C ( Cacao )				`CGFloat`
DO#	`float`		—
Java	`float`
Ir	`float32`	`float64`
Óxido	`f32`	`f64`
Rápido	`Float`o`Float32`	`Double`o`Float64`	`Float80`^[gramo]	`CGFloat`
D	`float`	`double`		`real`
Ceceo común	`single-float`	`double-float`	`float, short-float, long-float`
Esquema
ISLISP
Pascal ( FPC )	`single`	`double`		`real`
Visual Basic	`Single`	`Double`	—
Visual Basic .NET
Xojo
Pitón	—	`float`
JavaScript	—	`Number`^[7]	—
Jerga
Fortran	`REAL(KIND = n)`^[do]
PHP		`float`
Perl
Raku	`num32`	`num64`		`Num`
Rubí	—	`Float`	—
Escala	`Float`	`Double`
Semilla7	—	`float`
Charla informal	`Float`	`Double`
Windows PowerShell
OCaml	—	`float`	—
F#	`float32`	`float`
ML estándar	—			`real`
Haskell ( GHC )	`Float`	`Double`
Torre Eiffel	`REAL_32`	`REAL_64`
COBOL	`FLOAT-BINARY-7`^[mi]	`FLOAT-BINARY-34`^[mi]	`FLOAT-SHORT`, `FLOAT-LONG`,`FLOAT-EXTENDED`
Matemática	—	—		`Real`

^a Lasconstantes estándarreal shorts yreal lengthsse pueden usar para determinar cuántasshorts ylongs se pueden anteponer de manera útil ashort realylong real. Los tamaños reales deshort real,real, ylong realestán disponibles como las constantesshort max real,max realylong max realetc. Con las constantesshort small real,small realy disponibles para la máquina epsilonlong small real de cada tipo.
Las declaraciones ^b de precisión simple a menudo no se respetan
^c El valor denlo proporciona laSELECTED_REAL_KIND^{función intrínseca [8]} .
La opción de tiempo de ejecución de ALGOL 68 G--precision "number"puede establecer la precisión delong long reals en el "número" de dígitos significativos requeridos. Lasconstantes estándarlong long real width ylong long max realse pueden utilizar para determinar la precisión real.
^e Estos tipos de punto flotante IEEE se introducirán en el próximo estándar COBOL.
^f El mismo tamaño quedoubleen muchas implementaciones.
^g Swift admite el tipo de punto flotante de precisión extendida de 80 bits, equivalente along doubleen los lenguajes C.

Números complejos

	Entero	Precisión simple	Doble precisión	Precisión media y cuádruple, etc.
Ada ^[1]	—	`Complex`^[b]	`Complex`^[b]	`Complex`^[b]
ALGOL 68	—	`compl`	`long compl`etc.	`short compl`etc. y `long long compl`etc.
C ( C99 ) ^[9]	—	`float complex`	`double complex`	—
C++ (STL)	—	`std::complex<float>`	`std::complex<double>`
DO#	—	—	`System.Numerics.Complex` (.NET 4.0)
Java	—	—	—
Ir	—	`complex64`	`complex128`
D	—	`cfloat`	`cdouble`
Objetivo-C	—	—	—
Ceceo común	(entero complejo)	(flotante simple complejo)	(flotante doble complejo)	complejo
Esquema				—
Pascal	—	—
Visual Basic	—	—
Visual Basic .NET	—	—	`System.Numerics.Complex` (.NET 4.0)
Perl			`Math::Complex`
Raku		`complex64`	`complex128`	`Complex`
Pitón			`complex`	—
JavaScript	—	—
Jerga	—	—
Fortran		`COMPLEX(KIND = n)`^[a]
Rubí	`Complex`	—	`Complex`
Escala	—	—	—
Semilla7	—	—	`complex`
Charla informal	`Complex`	`Complex`	`Complex`
Windows PowerShell	—	—
OCaml	—	—	`Complex.t`
F#			`System.Numerics.Complex` (.NET 4.0)
ML estándar	—	—	—
Haskell ( GHC )	—	`Complex.Complex Float`	`Complex.Complex Double`
Torre Eiffel	—	—	—
COBOL	—	—	—
Matemática	`Complex`	—	—	`Complex`

^a El valor denlo proporciona laSELECTED_REAL_KIND^{función intrínseca [8]} .
^b Tipo genérico que puede instanciarse con cualquier tipo de punto flotante base.

Otros tipos de variables

	Texto		Booleano	Enumeración	Objeto / Universal
	Personaje	Cadena ^[a]	Booleano	Enumeración	Objeto / Universal
Ada ^[1]	`Character`	`String`, `Bounded_String`,`Unbounded_String`	`Boolean`	`(item₁, item₂, ...)`	`tagged null record`
ALGOL 68	`char`	`string`,`bytes`	`bool`,`bits`	— - Definido por el usuario	—
C ( C99 )	`char`,`wchar_t`	—	`bool`^[b]	`enum «name» { item₁, item₂, ... };`	`void *`
C++ (STL)	`char`,`wchar_t`	`«std::»string`	`bool`^[b]		`void *`
Objetivo-C	`unichar`	`NSString *`	`BOOL`		`id`
DO#	`char`	`string`	`bool`	`enum name { item₁« = value», item₂« = value», ... }`	objeto
Java	`char`	`String`	`boolean`	`enum name { item₁, item₂, ... }`	`Object`
Ir	`byte`,`rune`	`string`	`bool`	`const ( item₁ = iota item₂ ... )`	`interface{}`
Óxido	`char`	`String`	`bool`	`enum name { item₁« = value», item₂« = value», ... }`	`std::any::Any`
Rápido	`Character`	`String`	`Bool`	`enum name { case item₁, item₂, ... }`	`Any`
D	`char`	`string`	`bool`	`enum name { item₁, item₂, ... }`	`std.variant.Variant`
Ceceo común	`character`	`string`	`boolean`	`(member item₁ item₂ ...)`	`t`
Esquema
ISLISP
Pascal (ISO)	`char`	—	`boolean`	`( item₁, item₂, ... )`	—
Objeto Pascal ( Delphi )	`char`	`string`	`boolean`	`( item₁, item₂, ... )`	`variant`
Visual Basic	—	`String`	`Boolean`	`Enum name item₁ «= value» item₂ «= value» ... End Enum`	`[[Variant type\|Variant]]`
Visual Basic .NET	`Char`				`Object`
Xojo	—				`Object`o`Variant`
Pitón	- ^[d]	`str`	`bool`	`from enum import Enum class Name(Enum): item₁ = value item₂ = value ...`	`object`
JavaScript	- ^[d]	`String`	`Boolean`		`Object`
Jerga
Fortran	`CHARACTER(LEN = *)`	`CHARACTER(LEN = :), allocatable`	`LOGICAL(KIND = n)`^[F]		`CLASS(*)`
PHP	- ^[d]	`string`	`bool`		(se omite la declaración de tipo)
Perl	- ^[d]				`UNIVERSAL`
Raku	`Char`	`Str`	`Bool`	`enum name<item₁ item₂ ...>` `enum name <<:item₁(value) :item₂(value) ..>>`	`Mu`
Rubí	- ^[d]	`String`	`Object`^[do]		`Object`
Escala	`Char`	`String`	`Boolean`	`object name extends Enumeration { val item₁, item₂, ... = Value }`	`Any`
Semilla7	`char`	`string`	`boolean`	`const type: name is new enum item₁, item₂, ... end enum;`
Windows PowerShell
OCaml	`char`	`string`	`bool`	— ^[y]	—
F#				`type name = item₁ = value \|item₂ = value \| ...`	`obj`
ML estándar				— ^[y]	—
Haskell ( GHC )	`Char`	`String`	`Bool`	— ^[y]	—
Torre Eiffel	`CHARACTER`	`STRING`	`BOOLEAN`	—	`ANY`
COBOL	`PIC X`	`PIC X(string length)`o`PIC X«X...»`	`PIC 1«(number of digits)»`o`PIC 1«1...»`	—	`OBJECT REFERENCE`
Matemática	- ^[d]	`String`			—

^a específicamente, cadenas de longitud arbitraria y gestionadas automáticamente.
^b Este lenguaje representa un valor booleano como un entero donde falso se representa como un valor cero y verdadero como un valor distinto de cero.
^c Todos los valores se evalúan como verdaderos o falsos. Todo lo queTrueClassse evalúa como verdadero y todo lo queFalseClassse evalúa como falso.
^d Este lenguaje no tiene un tipo de carácter independiente. Los caracteres se representan como cadenas de longitud 1.
^e Las enumeraciones en este lenguaje son tipos algebraicos con solo constructores nulos
^f El valor denlo proporciona laSELECTED_INT_KIND^{función intrínseca [4]} .

Tipos derivados

Formación

	matriz de tamaño fijo		matriz de tamaño dinámico
	matriz unidimensional	matriz multidimensional	matriz unidimensional	matriz multidimensional
Ada ^[1]	`array (<first> .. <last>) of <type>` o `array (<discrete_type>) of <type>`	`array (<first₁> .. <last₁>, <first₂> .. <last₂>, ...) of <type>` o `array (<discrete_type₁>, <discrete_type₂>, ...) of <type>`	`array (<discrete_type> range <>) of <type>`	`array (<discrete_type₁> range <>, <discrete_type₂> range <>, ...) of <type>`
ALGOL 68	`[first:last]«modename»` o simplemente: `[size]«modename»`	`[first₁:last₁, first₂:last₂]«modename»` o etc. `[first₁:last₁][first₂:last₂]«modename»`	`flex[first:last]«modename»` o simplemente: `flex[size]«modename»`	`flex[first₁:last₁, first₂:last₂]«modename»` o `flex[first₁:last₁]flex[first₂:last₂]«modename» etc.`
C ( C99 )	`type name[size]`^[a]	`type name[size₁][size₂]`^[a]	`type *name` o dentro de un bloque: `int n = ...; type name[n]`
C++ (STL)	`«std::»array<type, size>`(C++11)		`«std::»vector<type>`
DO#	`type[]`	`type[,,...]`	`System.Collections.ArrayList` o `System.Collections.Generic.List<type>`
Java	`type[]`^[b]	`type[][]...`^[b]	`ArrayList or ArrayList<type>`
D	`type[size]`	`type[size₁][size₂]`	`type[]`
Ir	`[size]type`	`[size₁][size₂]...type`	`[]type`	`[][]type`
Óxido	`[type; size]`	`[[type; size₁]; size₂]`	`Vec<type>`	`Vec<Vec<type>>`
Rápido			`[type]`o`Array<type>`	`[[type]]`o`Array<Array<type>>`
Objetivo-C	`NSArray`		`NSMutableArray`
JavaScript	—	—	`Array`^[d]
Ceceo común	`(simple-array type (dimension))`	`(simple-array type (dimension1 dimension2))`	`(array type (dimension))`	`(array type (dimension1 dimension2))`
Esquema
ISLISP
Pascal	`array[first..last] of type`^[do]	`array[first₁..last₁] of array[first₂..last₂] ... of type`^[c] o ^[c] `array[first₁..last₁, first₂..last₂, ...] of type`	—	—
Objeto Pascal ( Delphi )	`array[first..last] of type`^[do]		`array of type`	`array of array ... of type`
Visual Basic	`Dim x(last) As type`	`Dim x(last₁, last₂,...) As type`
Visual Basic .NET	`type()`	`type(,,...)`	`System.Collections.ArrayList` o `System.Collections.Generic.List(Of type)`
Pitón			`list`
Jerga	`x = type[size];`	`x = type[size₁, size₂, ...];`
Fortran	`type :: name(size)`	`type :: name(size₁, size₂,...)`	`type, ALLOCATABLE :: name(:)`	`type, ALLOCATABLE :: name(:,:,...)`
PHP			`array`
Perl
Raku			`Array[type] or Array of type`
Rubí		`x = Array.new(size₁){ Array.new(size₂) }`	`Array`
Escala	`Array[type]`	`Array[...[Array[type]]...]`	`ArrayBuffer[type]`
Semilla7	`array type` o `array [idxType] type`	`array array type` o `array [idxType] array [idxType] type`	`array type` o `array [idxType] type`	`array array type` o `array [idxType] array [idxType] type`
Charla informal	`Array`		`OrderedCollection`
Windows PowerShell	`type[]`	`type[,,...]`
OCaml	`type array`	`type array ... array`
F#	`type []` o `type array`	`type [,,...]`	`System.Collections.ArrayList` o `System.Collections.Generic.List<type>`
ML estándar	`type vector or type array`
Haskell ( GHC )	`x = Array.array (0, size-1) list_of_association_pairs`	`x = Array.array ((0, 0,...), (size₁-1, size₂-1,...)) list_of_association_pairs`
COBOL	`level-number type OCCURS size «TIMES».`	Definición de matriz unidimensional...	`level-number type OCCURS min-size TO max-size «TIMES» DEPENDING «ON» size.`^[mi]	—

^a En la mayoría de las expresiones (excepto lossizeofy&), los valores de los tipos de matriz en C se convierten automáticamente en un puntero a su primer argumento. Consulte Sintaxis de C#Matrices para obtener más detalles sobre la sintaxis y las operaciones con punteros.
^b El formato similar a Ctype x[]funciona en Java, sin embargotype[] xes la forma preferida de declaración de matriz.
^c Los subrangos se utilizan para definir los límites de la matriz.
^d Las matrices de JavaScript son un tipo especial de objeto.
^e LaDEPENDING ONcláusula en COBOL no crea una verdadera matriz de longitud variable y siempre asignará el tamaño máximo de la matriz.

Otros tipos

	Tipos compuestos simples		Tipos de datos algebraicos	Sindicatos
	Archivos	Expresión de tupla	Tipos de datos algebraicos	Sindicatos
Ada ^[1]	`type name is «abstract» «tagged» «limited» [record field₁ : type; field₂ : type; ... end record \| null record]`	—	Cualquier combinación de registros, uniones y enumeraciones (así como referencias a ellos, habilitando tipos recursivos).	`type name (variation : discrete_type) is record case variation is when choice_list₁ => fieldname₁ : type; ... when choice_list₂ => fieldname₂ : type; ... ... end case; end record`
ALGOL 68	`struct (modename «fieldname», ...);`	Los tipos y operadores requeridos pueden ser definidos por el usuario		`union (modename, ...);`
C ( C99 )	`struct «name» {type name;...};`	—	—	`union {type name;...};`
Objetivo-C	`struct «name» {type name;...};`	—
C++	`struct «name» {type name;...};`^[b]	`«std::»tuple<type₁..type_n>`
DO#	`struct name {type name;...}`	`(val₁, val₂, ... )`		—
Java	- ^[a]
JavaScript		—
D	`struct name {type name;...}`		`std.variant.Algebraic!(type,...)`	`union {type name;...}`
Ir	`struct { «name» type ... }`
Óxido	`struct name {name: type, ...}`	`(val₁, val₂, ... )`	`enum name { Foo(types), ...}`	`union name {name: type, ...}`
Rápido	`struct name { var name «: type» ... }`	`(«name₁:» val₁, «name₂:» val₂, «name₃:» val₃, ... )`	`enum name { case Foo«(types)» case Bar «(types)» ... }`
Ceceo común	`(defstruct name slot-name (slot-name initial-value) (slot-name initial-value :type type) ...)`	`(cons val₁ val₂)`^[do]
Esquema	—
ISLISP
Pascal	`record name: type; ... end`	—	—	`record case type of value: (types); ... end`
Visual Basic
Visual Basic .NET	`Structure name Dim name As type ... End Structure`	`(val₁, val₂, ... )`
Pitón	- ^[a]	`«(»val₁, val₂, val₃, ... «)»`		—
Jerga	`struct {name [=value], ...}`
Fortran	`TYPE name type :: name ... END TYPE`
PHP	- ^[a]
Perl	- ^[d]			—
Raku	- ^[a]
Rubí	`OpenStruct.new({:name => value})`
Escala	`case class name(«var» name: type, ...)`	`(val₁, val₂, val₃, ... )`	`abstract class name case class Foo(«parameters») extends name case class Bar(«parameters») extends name ...` o una combinación de clases de casos y objetos de casos `abstract class name case object Foo extends name case object Bar extends name ...`
Windows PowerShell
OCaml	`type name = {«mutable» name : type;...}`	`«(»val₁, val₂, val₃, ... «)»`	`type name = Foo «of type» \| Bar «of type» \| ...`	—
F#	`type name = {«mutable» name : type;...}`	`«(»val₁, val₂, val₃, ... «)»`	`type name = Foo «of type» \| Bar «of type» \| ...`
ML estándar	`type name = {name : type,...}`	`(val₁, val₂, val₃, ... )`	`datatype name = Foo «of type» \| Bar «of type» \| ...`
Haskell	`data Name = Constr {name :: type,...}`	`(val₁, val₂, val₃, ... )`	`data Name = Foo «types» \| Bar «types» \| ...`
COBOL	`level-number name type clauses. level-number+n name type clauses. ...`	—	—	`name REDEFINES variable type.`

^a Sólo se admiten clases.
Las ^b struct en C++ son en realidad clases, pero tienen visibilidad pública predeterminada ytambién son objetos POD . C++11 extendió esto aún más, para hacer que las clases actúen de manera idéntica a los objetos POD en muchos más casos.
^c solo par
^d Aunque Perl no tiene registros, debido a que el sistema de tipos de Perl permite que diferentes tipos de datos estén en una matriz, los "hashes" (matrices asociativas) que no tienen un índice variable serían efectivamente lo mismo que los registros.
^e Las enumeraciones en este lenguaje son tipos algebraicos con solo constructores nulos

Declaraciones de variables y constantes

	variable	constante	escribir sinónimo
Ada ^[1]	`identifier : type« := initial_value»`^[mi]	`identifier : constant type := final_value`	`subtype identifier is type`
ALGOL 68	`modename name« := initial_value»;`	`modename name = value;`	`mode synonym = modename;`
C ( C99 )	`type name« = initial_value»;`	`enum{ name = value };`	`typedef type synonym;`
Objetivo-C		`enum{ name = value };`
C++		`const type name = value;`
DO#	`type name₁« = initial_value», name₂« = initial_value», ...;` o `var name = initial_value;`	`const type name = value, name = value, ...;` o `readonly type name = value, name = value, ... ;`	`using synonym = type;`
D	`type name« = initial_value»;` o `auto name = value;`	`const type name = value;` o `immutable type name = value;`	`alias type synonym;`
Java	`type name« = initial_value»;`	`final type name = value;`	—
JavaScript	`var name« = initial_value»;`o (desde ECMAScript 2015) `let name« = initial_value»;`	`const name = value;`(desde ECMAScript 2015)	—
Ir	`var name type« = initial_value»` o `name := initial_value`	`const name «type» = value`	`type synonym type`
Óxido ^[f]	`let mut name«: type»« = initial_value»;` `static mut NAME: type = value;`	`let name«: type»« = initial_value»;` `const NAME: type = value;` `static NAME: type = value;`	`type synonym = typename;`
Rápido	`var name «: type»« = initial_value»`	`let name «: type» = value`	`typealias synonym = type`
Ceceo común	`(defparameter name initial-value)` o `(defvar name initial-value)`	`(defconstant name value)`	`(deftype synonym () 'type)`
Esquema	`(define name initial_value)`
ISLISP	`(defglobal name initial_value)` o `(defdynamic name initial_value)`	`(defconstant name value)`	—
Pascual ^[a]	`name: type« = initial_value»`	`name = value`	`synonym = type`
Visual Basic	`Dim name «As type»`	Ver notas a la izquierda. Las constantes utilizan la misma sintaxis y: utilizar `Const`en lugar de`Dim` tienen una restricción solo para ciertos tipos primitivos `Const name₁ «As type» = value, name₂ «As type» = value, ...`
Visual Basic .NET ^[10]	La sintaxis de declaración de variables de VB.NET es inusualmente difícil de describir con precisión. Dado que existen los sufijos identificadores ("modificadores"): `type_character`, disponible como alternativa a una `As`cláusula para algunos tipos de datos primitivos; `nullable_specifier`; y `array_specifier`; Y eso a `modified_identifier`tiene la forma `identifier«type_character»«nullable_specifier»«array_specifier»`; a `modified_identifier_list`es una lista separada por comas de dos o más ocurrencias de `modified_identifier`; y a `declarator_list`es una lista de declaradores separados por comas, que puede tener la forma `identifier As object_creation_expression`(declarador de inicializador de objeto) , `modified_identifier «As non_array_type«array_rank_specifier»»« = initial_value»` (declarador único) , o `modified_identifier_list «As «non_array_type««array_rank_specifier»»` (declarador múltiple); Las declaraciones válidas tienen la forma , donde, a los efectos del análisis semántico, para convertirlas en una lista de declaradores únicos:`Dim declarator_listdeclarator_list` Las `As`cláusulas de cada declarador múltiple se distribuyen entre sus`modified_identifier_list` El declarador del inicializador de cada objeto se reemplaza con`As New type...As type = New type...` y para lo cual, para cada `identifier`, La cláusula a `type_character`y `As`no aparecen ambas; Si hay una `As`cláusula presente, an `array_rank_specifier`no aparece tanto como modificación del identificador como en el tipo de la `As`cláusula; se `unmodified_type`puede determinar, por la regla de que, Si hay una cláusula `type_character`o ,`As` `unmodified_type`es lo especificado por tal construcción, y que de lo contrario, o bien `Option Infer`debe estar encendido y `identifier`debe tener un inicializador, en cuyo caso `unmodified_type`es el del inicializador, o `Option Strict`debe estar desactivado, en cuyo caso `unmodified_type`es `Object`; `final_type`se `unmodified_type`antepone a sus modificadores ; es `final_type`un tipo válido; y Si `initial_value`está presente, o bien `Option Strict`está activado y `initial_value`tiene una conversión de ampliación a `final_type`, o `Option Strict`está desactivado y `initial_value`tiene una conversión estrecha a `final_type`. Si `Option Explicit`está desactivado, las variables no requieren declaración explícita; se declaran implícitamente cuando se utilizan:`name = initial_value`		`Imports synonym = type`
Xojo	`Dim name «As type»« = initial_value»`		—
Pitón	`name«: type» = initial_value`	—	`synonym = type`^[b]
Script de café	`name = initial_value`	—
Jerga	`name = initial_value;`		`typedef struct {...} typename`
Fortran	`type :: name`	`type, PARAMETER :: name = value`
PHP	`$name = initial_value;`	`define("name", value); const name = value (5.3+)`	—
Perl	`«my» $name« = initial_value»;`^[do]	`use constant name => value;`	—
Raku	`«my «type»» $name« = initial_value»;`^[do]	`«my «type»» constant name = value;`	`::synonym ::= type`
Rubí	`name = initial_value`	`Name = value`	`synonym = type`^[b]
Escala	`var name«: type» = initial_value`	`val name«: type» = value`	`type synonym = type`
Windows PowerShell	`«[type]» $name = initial_value`	—	—
Concha bash	`name=initial_value`	—	—
OCaml	`let name« : type ref» = ref value`^[d]	`let name «: type» = value`	`type synonym = type`
F#	`let mutable name «: type» = value`	`let name «: type» = value`
ML estándar	`val name «: type ref» = ref value`^[d]	`val name «: type» = value`
Haskell		`«name::type;» name = value`	`type Synonym = type`
Adelante	`VARIABLE name`(en algunos sistemas utilizar en su lugar)`value VARIABLE name`	`value CONSTANT name`
COBOL	`level-number name type clauses.`	`«0»1 name CONSTANT «AS» value.`	`level-number name type clauses «IS» TYPEDEF.`
Matemática	`name=initial_value`	—	—

^a Pascal tiene bloques de declaración. Ver funciones.
^b Los tipos son simplemente objetos regulares, por lo que puedes asignarlos.
^c En Perl, la palabra clave "my" limita el alcance de la variable al bloque.
^d Técnicamente, esto no declara que el nombre sea una variable mutable (en ML, todos los nombres solo se pueden vincular una vez); en cambio, declara que el nombre apunta a una estructura de datos de "referencia", que es una celda mutable simple. Luego, se puede leer y escribir en la estructura de datos utilizando los!y:=, respectivamente.
^e Si no se proporciona ningún valor inicial, se asigna automáticamente un valor no válido (que activará una excepción en tiempo de ejecución si se utiliza antes de que se haya asignado un valor válido). Si bien este comportamiento se puede suprimir, se recomienda en aras de la previsibilidad. Si no se puede encontrar un valor no válido para un tipo (por ejemplo, en el caso de un tipo entero sin restricciones), se elige en su lugar un valor válido, pero predecible.
^f En Rust, si no se le asigna ningún valor inicial a unaletolet muty nunca se le asigna más adelante, aparece una advertencia de "variable no utilizada". Si no se proporciona ningún valor para unaconstostaticostatic mut, aparece un error. Aparece un error de "variables globales sin mayúsculas" paraconstlas variables sin mayúsculas. Una vez definida,static mutsolo se puede asignar una variable en ununsafebloque o función.

Flujo de control

Condicionaldeclaraciones

	si	De lo contrario si	seleccionar caso	expresión condicional
Ada ^[1]	`if condition then statements «else statements» end if`	`if condition₁ then statements elsif condition₂ then statements ... «else statements» end if`	`case expression is when value_list₁ => statements when value_list₂ => statements ... «when others => statements» end case`	`(if condition₁ then expression₁ «elsif condition₂ then expression₂» ... else expression_n )` o `(case expression is when value_list₁ => expression₁ when value_list₂ => expression₂ ... «when others => expression_n» )`
Semilla7	`if condition then statements «else statements» end if`	`if condition₁ then statements elsif condition₂ then statements ... «else statements» end if`	`case expression of when set1 : statements ... «otherwise: statements» end case`
Módulo-2	`if condition then statements «else statements» end`	`if condition₁ then statements elsif condition₂ then statements ... «else statements» end`	`case expression of caseLabelList : statements \| ... «else statements» end`
ALGOL 68	`if condition then statements «else statements» fi`	`if condition then statements elif condition then statements fi`	`case switch in statements, statements«,... out statements» esac`	`( condition \| valueIfTrue \| valueIfFalse )`
ALGOL 68 (forma abreviada)	`( condition \| statements «\| statements» )`	`( condition \| statements \|: condition \| statements )`	`( variable \| statements,... «\| statements» )`
APL	`:If condition instructions «:Else instructions» :EndIf`	`:If condition instructions :ElseIf condition instructions ... «:Else instructions» :EndIf`	`:Select expression :Case case1 instructions ... «:Else instructions» :EndSelect`	`{condition:valueIfTrue ⋄ valueIfFalse}`
C ( C99 )	`if (condition) instructions «else instructions»` `instructions`Puede ser una sola declaración o un bloque en forma de:`{ statements }`	`if (condition) instructions else if (condition) instructions ... «else instructions»` o `if (condition) instructions else { if (condition) instructions }`	`switch (variable) { case case1: instructions «; break;» ... «default: instructions» }`	`condition ? valueIfTrue : valueIfFalse`
Objetivo-C
C++ (STL)
D
Java
JavaScript
PHP
DO#	`if (condition) instructions «else instructions»` `instructions`Puede ser una sola declaración o un bloque en forma de:`{ statements }`	`if (condition) instructions else if (condition) instructions ... «else instructions»`	`switch (variable) { case case₁: instructions «break_or_jump_statement» ... «default: instructions break_or_jump_statement» }` Todos los casos no vacíos deben terminar con una instrucción `break`or `goto case`(es decir, no pueden pasar al siguiente caso). `default`No es necesario que el caso aparezca al final.	`condition ? valueIfTrue : valueIfFalse`
Windows PowerShell	`if (condition) instruction «else instructions»`	`if (condition) { instructions } elseif (condition) { instructions } ... «else { instructions }»`	`switch (variable) { case1{instructions «break;» } ... «default { instructions }»}`
Ir	`if condition {instructions} «else {instructions}»`	`if condition {instructions} else if condition {instructions} ... «else {instructions}»` o `switch { case condition: instructions ... «default: instructions» }`	`switch variable { case case₁: instructions ... «default: instructions» }`
Rápido	`if condition {instructions} «else {instructions}»`	`if condition {instructions} else if condition {instructions} ... «else {instructions}»`	`switch variable { case case₁: instructions ... «default: instructions» }`
Perl	`if (condition) {instructions} «else {instructions}»` o `unless (notcondition) {instructions} «else {instructions}»`	`if (condition) {instructions} elsif (condition) {instructions} ... «else {instructions}»` o `unless (notcondition) {instructions} elsif (condition) {instructions} ... «else {instructions}»`	`use feature "switch"; ... given (variable) { when (case₁) { instructions } ... «default { instructions }» }`	`condition ? valueIfTrue : valueIfFalse`
Raku	`if condition {instructions} «else {instructions}»` o `unless notcondition {instructions}`	`if condition {instructions} elsif condition {instructions} ... «else {instructions}`	`given variable { when case₁ { instructions } ... «default { instructions }» }`	`condition ?? valueIfTrue !! valueIfFalse`
Rubí	`if condition instructions «else instructions»`	`if condition instructions elsif condition instructions ... «else instructions» end`	`case variable when case₁ instructions ... «else instructions» end`	`condition ? valueIfTrue : valueIfFalse`
Escala	`if (condition) {instructions} «else {instructions}»`	`if (condition) {instructions} else if (condition) {instructions} ... «else {instructions}»`	`expression match { case pattern1 => expression case pattern2 => expression ... «case _ => expression» }`^[b]	`if (condition) valueIfTrue else valueIfFalse`
Charla informal	`condition ifTrue: trueBlock «ifFalse: falseBlock» end`			`condition ifTrue: trueBlock ifFalse: falseBlock`
Ceceo común	`(when condition instructions)` o o `(unless condition instructions)` `(if condition (progn instructions) «(progn instructions)»)`	`(cond (condition1 instructions) (condition2 instructions) ... «(t instructions)»)`	`(case expression (case1 instructions) (case2 instructions) ... «(otherwise instructions)»)`	`(if test then else)` o `(cond (test1 value1) (test2 value2) ...))`
Esquema	`(when condition instructions)` o `(if condition (begin instructions) «(begin instructions)»)`	`(cond (condition1 instructions) (condition2 instructions) ... «(else instructions)»)`	`(case (variable) ((case1) instructions) ((case2) instructions) ... «(else instructions)»)`	`(if condition valueIfTrue valueIfFalse)`
ISLISP	`(if condition (progn instructions) «(progn instructions)»)`	`(cond (condition1 instructions) (condition2 instructions) ... «(t instructions)»)`	`(case expression (case1 instructions) (case2 instructions) ... «(t instructions)»)`	`(if condition valueIfTrue valueIfFalse)`
Pascal	`if condition then begin instructions end «else begin instructions end»'`^[do]	`if condition then begin instructions end else if condition then begin instructions end ... «else begin instructions end»`^[do]	`case variable of case1: instructions ... «else: instructions» end`^[do]
Visual Basic	`If condition Then instructions «Else instructions» End If` De una sola línea, cuando `instructions`son :`instruction₁ : instruction₂ : ...` `If condition Then instructions «Else instructions»`	`If condition Then instructions ElseIf condition Then instructions ... «Else instructions» End If` De una sola línea: consulte la nota sobre lenguajes similares a C; la `Else`cláusula de una declaración de una sola línea `If`puede contener otra declaración de una sola línea `If`.	`Select« Case» variable Case case_pattern₁ instructions ... «Case Else instructions» End Select`	`IIf(condition, valueIfTrue, valueIfFalse)`
Visual Basic .NET				`If(condition, valueIfTrue, valueIfFalse)`
Xojo				`If(condition, valueIfTrue, valueIfFalse)`
Pitón ^[a]	`if condition : Tab ↹instructions «else: Tab ↹instructions»`	`if condition : Tab ↹instructions elif condition : Tab ↹instructions ... «else: Tab ↹instructions»`	Python 3.10+: `match variable: Tab ↹case case1: Tab ↹Tab ↹instructions Tab ↹case case2: Tab ↹Tab ↹instructions`	Python 2.5+: `valueIfTrue if condition else valueIfFalse`
Jerga	`if (condition) { instructions } «else { instructions }»`	`if (condition) { instructions } else if (condition) { instructions } ... «else { instructions }»`	`switch (variable) { case case1: instructions } { case case2: instructions } ...`
Fortran	`IF (condition) THEN instructions ELSE instructions ENDIF`	`IF (condition) THEN instructions ELSEIF (condition) THEN instructions ... ELSE instructions ENDIF`	`SELECT CASE(variable) CASE (case1) instructions ... CASE DEFAULT instructions END SELECT`
Adelante	`condition IF instructions « ELSE instructions» THEN`	`condition IF instructions ELSE condition IF instructions THEN THEN`	`value CASE case OF instructions ENDOF case OF instructions ENDOF default instructions ENDCASE`	`condition IF valueIfTrue ELSE valueIfFalse THEN`
OCaml	`if condition then begin instructions end «else begin instructions end»`	`if condition then begin instructions end else if condition then begin instructions end ... «else begin instructions end»`	`match value with pattern1 -> expression \| pattern2 -> expression ... «\| _ -> expression»`^[b]	`if condition then valueIfTrue else valueIfFalse`
F#	Modo de sintaxis ligera: Ya sea en una sola línea o con sangría como se muestra a continuación: Modo de sintaxis detallada: Igual que ML estándar.`if condition then Tab ↹instructions «else Tab ↹instructions»`	Modo de sintaxis ligera: en una sola línea o con sangría como se muestra a continuación: Modo de sintaxis detallada: igual que ML estándar. `if condition then Tab ↹instructions elif condition then Tab ↹instructions ... «else Tab ↹instructions»`
ML estándar	`if condition then «(»instructions «)» else «(» instructions «)»`	`if condition then «(»instructions «)» else if condition then «(» instructions «)» ... else «(» instructions «)»`	`case value of pattern1 => expression \| pattern2 => expression ... «\| _ => expression»`^[b]
Haskell ( GHC )	`if condition then expression else expression` o o `when condition (do instructions)` `unless notcondition (do instructions)`	`result \| condition = expression \| condition = expression \| otherwise = expression`	`case value of { pattern1 -> expression; pattern2 -> expression; ... «_ -> expression» }`^[b]
Concha bash	`if condition-command; then expression «else expression» fi`	`if condition-command; then expression elif condition-command; then expression «else expression» fi`	`case "$variable" in "$condition1" ) command... "$condition2" ) command... esac`
Script de café	`if condition then expression «else expression»` o o o o `if condition expression «else expression»` `expression if condition` `unless condition expression «else expression»` `expression unless condition`	`if condition then expression else if condition then expression «else expression»` o o `if condition expression else if condition expression «else expression»` `unless condition expression else unless condition expression «else expression»`	`switch expression when condition then expression else expression` o `switch expression when condition expression «else expression»`	Todas las condiciones son expresiones.
COBOL	`IF condition «THEN» expression «ELSE expression».`^[d]		`EVALUATE expression «ALSO expression...» WHEN case-or-condition «ALSO case-or-condition...» expression ... «WHEN OTHER expression» END-EVALUATE`
Óxido	`if condition { expression }« else { expression }»`	`if condition { expression } else if condition { expression }« else { expression }»`	`match variable { pattern1 => expression, pattern2 => expression, pattern3 => expression, «_ => expression» }`^[^ser]	Todas las condiciones son expresiones
	si	De lo contrario si	seleccionar caso	expresión condicional

^a Se puede escribir una sola instrucción en la misma línea después de los dos puntos. Varias instrucciones se agrupan en un bloque que comienza en una nueva línea (la sangría es obligatoria). La sintaxis de expresión condicional no sigue esta regla.
^b Esto es una coincidencia de patrones y es similar al caso de selección, pero no es lo mismo. Se suele utilizar para deconstruir tipos de datos algebraicos .
^c En los lenguajes de la familia Pascal, el punto y coma no forma parte de la declaración. Es un separador entre declaraciones, no un terminador.
Se puede utilizar ^d END-IF en lugar del punto al final.
^e En Rust, la coma (,) al final de un brazo de coincidencia se puede omitir después del último brazo de coincidencia, o después de cualquier brazo de coincidencia en el que la expresión sea un bloque (termina en corchetes de coincidencia posiblemente vacíos{}).

Sentencias de bucle

	bucle while	hacer bucle while	(bucle for controlado por conteo)	para cada uno
Ada ^[1]	`while condition loop statements end loop`	`loop statements exit when not condition end loop`	`for index in «reverse» [first .. last \| discrete_type] loop statements end loop`	`for item of «reverse» iterator loop statements end loop` o ^[b] `(for [all \| some] [in \| of] [first .. last \| discrete_type \| iterator] => predicate)`
ALGOL 68	`«for index» «from first» «by increment» «to last» «while condition» do statements od`			`for key «to upb list» do «typename val=list[key];» statements od`
ALGOL 68	`«while condition» do statements od`	`«while statements; condition» do statements od`	`«for index» «from first» «by increment» «to last» do statements od`
APL	`:While condition statements :EndWhile`	`:Repeat statements :Until condition`	`:For var«s» :In list statements :EndFor`	`:For var«s» :InEach list statements :EndFor`
C ( C99 )	`instructions`Puede ser una sola declaración o un bloque en forma de:`{ statements }` `while (condition) instructions`	`do instructions while (condition);`	`for («type» i = first; i <= last; i++) instructions`	—
Objetivo-C				`for (type item in set) instructions`
C++ (STL)				`«std::»for_each(start, end, function)` Desde C++11 : `for (type item : set) instructions`
DO#				`foreach (type item in set) instructions`
Java				`for (type item : set) instructions`
JavaScript			`for (var i = first; i <= last; i++) instructions`	Desde EcmaScript 2015: ^[11] `for (var item of set) instructions`
PHP			`foreach (range(first, last) as $i) instructions` o `for ($i = first; $i <= last; $i++) instructions`	`foreach (set as item) instructions` o `foreach (set as key => item) instructions`
Windows PowerShell			`for ($i = first; $i -le last; $i++) instructions`	`foreach (item in set) instructions`
D			`foreach (i; first ... last) instructions`	`foreach («type» item; set) instructions`
Ir	`for condition { instructions }`		`for i := first; i <= last; i++ { instructions }`	`for key, item := range set { instructions }`
Rápido	`while condition { instructions }`	2.x: 1.x: `repeat { instructions } while condition` `do { instructions } while condition`	`for i = first ... last { instructions }` o o `for i = first ..< last+1 { instructions }` `for var i = first; i <= last; i++ { instructions }`	`for item in set { instructions }`
Perl	`while (condition) { instructions }` o `until (notcondition) { instructions }`	`do { instructions } while (condition)` o `do { instructions } until (notcondition)`	`for«each» «$i» (first .. last) { instructions }` o `for ($i = first; $i <= last; $i++) { instructions }`	`for«each» «$item» (set) { instructions }`
Raku	`while condition { instructions }` o `until notcondition { instructions }`	`repeat { instructions } while condition` o `repeat { instructions } until notcondition`	`for first..last -> $i { instructions }` o `loop ($i = first; $i <=last; $i++) { instructions }`	`for set« -> $item» { instructions }`
Rubí	`while condition instructions end` o `until notcondition instructions end`	`begin instructions end while condition` o `begin instructions end until notcondition`	`for i in first..last instructions end` o o `for i in first...last+1 instructions end` `first.upto(last) { \|i\| instructions }`	`for item in set instructions end` o `set.each { \|item\| instructions }`
Concha bash	`while condition ;do instructions done` o `until notcondition ;do instructions done`	—	`for ((i = first; i <= last; ++i)) ; do instructions done`	`for item in set ;do instructions done`
Escala	`while (condition) { instructions }`	`do { instructions } while (condition)`	`for (i <- first to last «by 1») { instructions }` o `first to last «by 1» foreach (i => { instructions })`	`for (item <- set) { instructions }` o `set foreach (item => { instructions })`
Charla informal	`conditionBlock whileTrue: loopBlock`	`loopBlock doWhile: conditionBlock`	`first to: last do: loopBlock`	`collection do: loopBlock`
Ceceo común	`(loop while condition do instructions)` o `(do () (notcondition) instructions)`	`(loop do instructions while condition)`	`(loop for i from first to last «by 1» do instructions)` o o `(dotimes (i N) instructions)` `(do ((i first (1+ i))) ((>=i last)) instructions)`	`(loop for item in list do instructions)` o o o o `(loop for item across vector do instructions)` `(dolist (item list) instructions)` `(mapc function list)` `(map type function sequence)`
Esquema	`(do () (notcondition) instructions)` o `(let loop () (if condition (begin instructions (loop))))`	`(let loop () (instructions (if condition (loop))))`	`(do ((i first (+ i 1))) ((>= i last)) instructions)` o `(let loop ((i first)) (if (< i last) (begin instructions (loop (+ i 1)))))`	`(for-each (lambda (item) instructions) list)`
ISLISP	`(while condition instructions)`	`(tagbody loop instructions (if condition (go loop))`	`(for ((i first (+ i 1))) ((>= i last)) instructions)`	`(mapc (lambda (item) instructions) list)`
Pascal	`while condition do begin instructions end`	`repeat instructions until notcondition;`	`for i := first «step 1» to last do begin instructions end;`^[a]	`for item in set do instructions`
Visual Basic	`Do While condition instructions Loop` o o (Visual Basic .NET utiliza en su lugar) `Do Until notcondition instructions Loop` `While condition instructions WendEnd While`	`Do instructions Loop While condition` o `Do instructions Loop Until notcondition`	`i`Debe declararse previamente. `For i = first To last «Step 1» instructions Next i`	`For Each item In set instructions Next item`
Visual Basic .NET			`For i« As type» = first To last« Step 1» instructions Next« i»`^[a]	`For Each item« As type» In set instructions Next« item»`
Xojo	`While condition instructions Wend`	`Do Until notcondition instructions Loop` o `Do instructions Loop Until notcondition`		`For Each item« As type» In set instructions Next« item»`
Pitón	`while condition : Tab ↹instructions «else: Tab ↹instructions»`	—	Python 3.x: Python 2.x: `for i in range(first, last+1): Tab ↹instructions «else: Tab ↹instructions»` `for i in xrange(first, last+1): Tab ↹instructions «else: Tab ↹instructions»`	`for item in set: Tab ↹instructions «else: Tab ↹instructions»`
Jerga	`while (condition) { instructions } «then optional-block»`	`do { instructions } while (condition) «then optional-block»`	`for (i = first; i <= last; i++) { instructions } «then optional-block»`	`foreach item(set) «using (what)» { instructions } «then optional-block»`
Fortran	`DO WHILE (condition) instructions ENDDO`	`DO instructions IF (condition) EXIT ENDDO`	`DO I = first,last instructions ENDDO`	—
Adelante	`BEGIN «instructions» condition WHILE instructions REPEAT`	`BEGIN instructions condition UNTIL`	`limit start DO instructions LOOP`	—
OCaml	`while condition do instructions done`	—	`for i = first to last do instructions done`	`Array.iter (fun item -> instructions) array` o `List.iter (fun item -> instructions) list`
F#	`while condition do Tab ↹instructions`	—	`for i = first to last do Tab ↹instructions`	`foritem in set do Tab ↹instructions` o `Seq.iter (fun item -> instructions) set`
ML estándar	`while condition do ( instructions )`	—		`Array.app (fn item => instructions) array` o `app (fn item => instructions) list`
Haskell ( GHC )	—		`Control.Monad.forM_ [first..last] (\i -> do instructions)`	`Control.Monad.forM_list (\item -> do instructions)`
Torre Eiffel	`from setup until condition loop instructions end`
Script de café	`while condition expression` o o o o o `expression while condition` `while condition then expression` `until condition expression` `expression until condition` `until expression then condition`	—	`for i in [first..last] expression` o o `for i in [first..last] then expression` `expression for i in [first..last]`	`for item in set expression` o o `for item in set then expression` `expression for item in set`
COBOL	`PERFORM procedure-1 «THROUGH procedure-2» ««WITH» TEST BEFORE» UNTIL condition`^[c] o `PERFORM ««WITH» TEST BEFORE» UNTIL condition expression END-PERFORM`	`PERFORM procedure-1 «THROUGH procedure-2» «WITH» TEST AFTER UNTIL condition`^[c] o `PERFORM «WITH» TEST AFTER UNTIL condition expression END-PERFORM`	`PERFORM procedure-1 «THROUGH procedure-2» VARYING i FROM first BY increment UNTIL i > last`^[d] o ^[d] `PERFORM VARYING i FROM first BY increment UNTIL i > last expression END-PERFORM`	—
Óxido	`while condition { expression }`	`loop { expression if condition { break; } }`	`for i in first..last+1 { expression }` o `for i in first..=last { expression }`	`for item in set { expression }`^[e] o ^[e] `set.into_iter().for_each(\|item\| expression);`

^a "stepn" se utiliza para cambiar el intervalo del bucle. Sistepse omite " ", el intervalo del bucle es 1.
^b Esto implementa el cuantificador universal ("para todos" o "") así como el cuantificador existencial ("existe" o ""). $\forall$ $\exists$
THRUSe puede utilizar ^cTHROUGH en lugar de .
«IS» GREATER «THAN»Se puede utilizar ^d> en lugar de .
^El tipo de expresión de conjunto debe implementar el rasgostd::iter::IntoIterator.

Excepciones

	tirar	entrenador de animales	afirmación
Ada ^[1]	`raise exception_name «with string_expression»`	`begin statements exception when exception_list₁ => statements; when exception_list₂ => statements; ... «when others => statements;» end`^[b]	`pragma Assert («Check =>» boolean_expression ««Message =>» string_expression») [function \| procedure \| entry] with Pre => boolean_expression Post => boolean_expression any_type with Type_Invariant => boolean_expression`
APL	`«string_expression» ⎕SIGNAL number_expression`	`:Trap number«s»_expression statements «:Case number«s»_expression statements» ... «:Else number«s»_expression statements» :EndTrap`	`«string_expression» ⎕SIGNAL 98/⍨~condition`
C ( C99 )	`longjmp(state, exception);`	`switch (setjmp(state)) { case 0: instructions break; case exception: instructions ... }`	`assert(condition);`
C++	`throw exception;`	`try { instructions } catch «(exception)» { instructions } ...`	`assert(condition);`
DO#		`try { instructions } catch «(exception« name»)» { instructions } ... «finally { instructions }»`	`System.Diagnostics.Debug.Assert(condition);` o `System.Diagnostics.Trace.Assert(condition);`
Java		`try { instructions } catch (exception) { instructions } ... «finally { instructions }»`	`assert condition «: description»;`
JavaScript		`try { instructions } catch (exception) { instructions} «finally { instructions }»`	?
D		`try { instructions } catch (exception) { instructions } ... «finally { instructions }»`	`assert(condition);`
PHP		`try { instructions } catch (exception) { instructions } ... «finally { instructions }»`	`assert(condition);`
Jerga		`try { instructions } catch «exception» { instructions } ... «finally { instructions }»`	?
Windows PowerShell		`trap «[exception]» { instructions } ... instructions` o `try { instructions } catch «[exception]» { instructions } ... «finally { instructions }»`	`[Debug]::Assert(condition)`
Objetivo-C	`@throw exception;`	`@try { instructions } @catch (exception) { instructions } ... «@finally { instructions }»`	`NSAssert(condition, description);`
Rápido	`throw exception`(2.x)	`do { try expression ... instructions } catch exception { instructions } ...`(2.x)	`assert(condition«, description»)`
Perl	`die exception;`	`eval { instructions }; if ($@) { instructions }`	?
Raku	`die exception;`	`try { instructions CATCH { when exception { instructions } ...}}`	?
Rubí	`raise exception`	`begin instructions rescue exception instructions ... «else instructions» «ensure instructions» end`
Charla informal	`exception raise`	`instructionBlock on: exception do: handlerBlock`	`assert: conditionBlock`
Ceceo común	`(error "exception")` o o `(error type arguments)` `(error (make-condition type arguments))`	`(handler-case (progn instructions) (exception instructions) ...)` o ^[a] `(handler-bind (condition (lambda instructions «invoke-restart restart args»)) ...)`	`(assert condition)` o o `(assert condition «(place) «error»»)` `(check-type var type)`
Esquema ( R ⁶ RS )	`(raise exception)`	`(guard (con (condition instructions) ...) instructions)`	?
ISLISP	`(error "error-string" objects)` o `(signal-condition condition continuable)`	`(with-handler handler form* )`	?
Pascal	`raise Exception.Create()`	`try Except on E: exception do begin instructions end; end;`	?
Visual Basic	`Err.Raise ERRORNUMBER`	`With New Try: On Error Resume Next OneInstruction .Catch: On Error GoTo 0: Select Case .Number Case SOME_ERRORNUMBER instructions End Select: End With` '* Probar clase * Descripción privada mstr como cadena Número privado mlng como largo Sub pública Catch () mstrDescription = Err . Descripción mlngNumber = Err . Número Fin Sub Propiedad pública Obtener número () Como número largo = mlngNumber Fin de propiedad Propiedad pública Obtener descripción () como cadena Descripción = mstrDescription Fin de la propiedad ^[12]	`Debug.Assert condition`
Visual Basic .NET	`Throw exception` o `Error errorcode`	`Try instructions Catch« name As exception»« When condition» instructions ... «Finally instructions» End Try`	`System.Diagnostics.Debug.Assert(condition)` o `System.Diagnostics.Trace.Assert(condition)`
Xojo	`Raise exception`	`Try instructions Catch «exception» instructions ... «Finally instructions» End Try`	—
Pitón	`raise exception`	`try: Tab ↹instructions except «exception»: Tab ↹instructions ... «else: Tab ↹instructions» «finally: Tab ↹instructions»`	`assert condition`
Fortran	—
Adelante	`code THROW`	`xt CATCH ( code or 0 )`	—
OCaml	`raise exception`	`try expression with pattern -> expression ...`	`assert condition`
F#	`raise exception`	`try expression with pattern -> expression ...` o `try expression finally expression`	`assert condition`
ML estándar	`raise exception «arg»`	`expression handle pattern => expression ...`
Haskell ( GHC )	`throw exception` o `throwError expression`	`catch tryExpression catchExpression` o `catchError tryExpression catchExpression`	`assert condition expression`
COBOL	`RAISE «EXCEPTION» exception`	`USE «AFTER» EXCEPTION OBJECT class-name.` o o o `USE «AFTER» EO class-name.` `USE «AFTER» EXCEPTION CONDITION exception-name «FILE file-name».` `USE «AFTER» EC exception-name «FILE file-name».`	—
Óxido	No ^[13]		`assert!(condition)`

^a Common Lisp permitewith-simple-restartydefinir reinicios para su uso conrestart-case.Las condiciones no controladas pueden hacer que la implementación muestre un menú de reinicios al usuario antes de desenrollar la pila.restart-bindinvoke-restart
^b Las excepciones no detectadas se propagan a la ejecución que encierra dinámicamente la parte más interna. Las excepciones no se propagan entre tareas (a menos que estas tareas estén sincronizadas en un punto de encuentro).

Otras declaraciones de flujo de control

	bloque de salida (salto)	continuar	etiqueta	rama ( ir a)	valor de retorno del generador
Ada ^[1]	`exit «loop_name» «when condition»`	—	`label:`	`goto label`	—
ALGOL 68	`value exit;`...	`do statements; skip exit; label: statements od`	`label:`...	`go to label; ... goto label; ... label; ...`	`yield(value)` ( Devolución de llamada ) ^[14]
APL	`:Leave`	`:Continue`	`label:`	`→label` o `:GoTo label`	—
C ( C99 )	`break;`	`continue;`	`label:`	`goto label;`	—
Objetivo-C
C++ (STL)
D
DO#					`yield return value;`
Java	`break «label»;`	`continue «label»;`		—
JavaScript	`break «label»;`	`continue «label»;`		—	`yield value«;»`
PHP	`break «levels»;`	`continue «levels»;`		`goto label;`	`yield «key =>» value;`
Perl	`last «label»;`	`next «label»;`
Raku	`last «label»;`	`next «label»;`
Ir	`break «label»`	`continue «label»`		`goto label`
Rápido	`break «label»`	`continue «label»`		—
Concha bash	`break «levels»`	`continue «levels»`	—	—	—
Ceceo común	`(return)` o o `(return-from block)` `(loop-finish)`		`(tagbody tag ... tag ...)`	`(go tag)`
Esquema
ISLISP	`(return-from block)`		`(tagbody tag ... tag ...)`	`(go tag)`
Pascal (ISO)	—		`label:`^[a]	`goto label;`	—
Pascal ( FPC )	`break;`	`continue;`	`label:`^[a]	`goto label;`
Visual Basic	`Exit block`Alternativamente, para los métodos, `Return`	—	`label:`	`GoTo label`
Xojo		`Continue block`
Visual Basic .NET		`Continue block`			`Yield value`
Pitón	`break`	`continue`	—		`yield value`
Juego de rol IV	`LEAVE;`	`ITER;`
Jerga	`break;`	`continue;`
Fortran	`EXIT`	`CYCLE`	`label`^[b]	`GOTO label`	—
Rubí	`break`	`next`
Windows PowerShell	`break «label»`	`continue`
OCaml	—
F#
ML estándar
Haskell ( GHC )
COBOL	`EXIT PERFORM`o `EXIT PARAGRAPH`o `EXIT SECTION`o`EXIT.`	`EXIT PERFORM CYCLE`	`label «SECTION».`	`GO TO label`	—

^a Pascal tiene bloques de declaración. Ver funciones.
La etiqueta ^b debe ser un número entre 1 y 99999.

Funciones

Consulte programación reflexiva para llamar y declarar funciones mediante cadenas.

	llamando a una función	Función básica/nula	función que devuelve valor	función principal requerida
Ada ^[1]	`foo «(parameters)»`	`procedure foo «(parameters)» is begin statements end foo`	`function foo «(parameters)» return type is begin statements end foo`	—
ALGOL 68	`foo «(parameters)»;`	`proc foo = «(parameters)» void: ( instructions );`	`proc foo = «(parameters)» rettype: ( instructions ...; retvalue );`	—
APL	`«parameters» foo parameters`	`foo←{ statements }`	`foo←{ statements }`	—
C ( C99 )	`foo(«parameters»)`	`void foo(«parameters») { instructions }`	`type foo(«parameters») { instructions ... return value; }`	`«global declarations» int main(«int argc, char *argv[]») { instructions }`
Objetivo-C
C++ (STL)
Java				`public static void main(String[] args) { instructions }` o `public static void main(String... args) { instructions }`
D				`int main(«char[][] args») { instructions}` o o o `int main(«string[] args») { instructions}` `void main(«char[][] args») { instructions}` `void main(«string[] args») { instructions}`
DO#		Igual que el anterior; alternativamente, si solo hay una declaración: `void foo(«parameters») => statement;`	Igual que el anterior; alternativamente, si es lo suficientemente simple como para ser una expresión: `void foo(«parameters») => expression;`	`static void Main(«string[] args») method_body` En cambio, puede devolver `int`. (a partir de C# 7.1:) Puede devolver `Task`o `Task<int>`, y si es así, puede ser `async`.
JavaScript		`function foo(«parameters») { instructions }` o o `var foo = function («parameters») { instructions }` `var foo = new Function ("«parameter»", ..., "«last parameter»" "instructions");`	`function foo(«parameters») { instructions ... return value; }`	—
Ir		`func foo(«parameters») { instructions }`	`func foo(«parameters») type { instructions ... return value }`	`func main() { instructions }`
Rápido		`func foo(«parameters») { instructions }`	`func foo(«parameters») -> type { instructions ... return value }`	—
Ceceo común	`(foo «parameters»)`	`(defun foo («parameters») instructions)` o `(setf (symbol-function 'symbol) function)`	`(defun foo («parameters») ... value)`	—
Esquema		`(define (foo parameters) instructions)` o `(define foo (lambda (parameters) instructions))`	`(define (foo parameters) instructions... return_value)` o `(define foo (lambda (parameters) instructions... return_value))`
ISLISP		`(defun foo («parameters») instructions)`	`(defun foo («parameters») ... value)`
Pascal	`foo«(parameters)»`	`procedure foo«(parameters)»; «forward;»^[a] «label label declarations» «const constant declarations» «type type declarations» «var variable declarations» «local function declarations» begin instructions end;`	`function foo«(parameters)»: type; «forward;»^[a] «label label declarations» «const constant declarations» «type type declarations» «var variable declarations» «local function declarations» begin instructions; foo := value end;`	`program name; «label label declarations» «const constant declarations» «type type declarations» «var variable declarations» «function declarations» begin instructions end.`
Visual Basic	`Foo(«parameters»)`	`Sub Foo«(parameters)» instructions End Sub`	`Function Foo«(parameters)»« As type» instructions Foo = value End Function`	`Sub Main() instructions End Sub`
Visual Basic .NET			Igual que el anterior; alternativamente: `Function Foo«(parameters)»« As type» instructions Return value End Function` La `As`cláusula no es necesaria si `Option Strict`está desactivada. Se puede utilizar un carácter de tipo en lugar de la `As`cláusula. Si el control sale de la función sin que se haya especificado explícitamente un valor de retorno, la función devuelve el valor predeterminado para el tipo de retorno.	`Sub Main(««ByVal »args() As String») instructions End Sub`o `Function Main(««ByVal »args() As String») As Integer instructions End Function`
Xojo
Pitón	`foo(«parameters»)`	`def foo(«parameters»): Tab ↹instructions`	`def foo(«parameters»): Tab ↹instructions Tab ↹return value`	—
Jerga	`foo(«parameters» «;qualifiers»)`	`define foo («parameters») { instructions }`	`define foo («parameters») { instructions ... return value; }`	`public define slsh_main () { instructions }`
Fortran	`foo («arguments») CALL sub_foo («arguments»)`^[do]	`SUBROUTINE sub_foo («arguments») instructions END SUBROUTINE`^[do]	`type FUNCTION foo («arguments») instructions ... foo = value END FUNCTION`^[do]	`PROGRAM main instructions END PROGRAM`
Adelante	`«parameters» FOO`	`: FOO « stack effect comment: ( before -- ) » instructions ;`	`: FOO « stack effect comment: ( before -- after ) » instructions ;`	—
PHP	`foo(«parameters»)`	`function foo(«parameters») { instructions }`	`function foo(«parameters») { instructions ... return value; }`	—
Perl	`foo(«parameters»)` o `&foo«(parameters)»`	`sub foo { «my (parameters) = @_;» instructions }`	`sub foo { «my (parameters) = @_;» instructions... «return» value; }`
Raku	`foo(«parameters»)` o `&foo«(parameters)»`	`«multi »sub foo(parameters) { instructions }`	`«our «type» »«multi »sub foo(parameters) { instructions ... «return» value; }`
Rubí	`foo«(parameters)»`	`def foo«(parameters)» instructions end`	`def foo«(parameters)» instructions «return» value end`
Óxido	`foo(«parameters»)`	`fn foo(«parameters») { instructions }`	`fn foo(«parameters») -> type { instructions }`	`fn main() { instructions }`
Escala	`foo«(parameters)»`	`def foo«(parameters)»«: Unit =» { instructions }`	`def foo«(parameters)»«: type» = { instructions ... «return» value }`	`def main(args: Array[String]) { instructions }`
Windows PowerShell	`foo «parameters»`	`function foo { instructions };` o `function foo { «param(parameters)» instructions }`	`function foo «(parameters)» { instructions ... return value };` o `function foo { «param(parameters)» instructions ... return value }`	—
Concha bash	`foo «parameters»`	`function foo { instructions }` o `foo () { instructions }`	`function foo { instructions return «exit_code» }` o `foo () { instructions return «exit_code» }`
Concha bash	`foo «parameters»`	parámetros `$n`( $1 , $2 , $3 , ...) `$@`(todos los parámetros) `$#`(el número de parámetros) `$0`(este nombre de función)
OCaml	`foo parameters`	`let «rec» foo parameters = instructions`	`let «rec» foo parameters = instructions... return_value`
F#		`let «rec» foo parameters = instructions`	`let «rec» foo parameters = instructions... return_value`	`[<EntryPoint>] let main args = instructions`
ML estándar		`fun foo parameters = ( instructions )`	`fun foo parameters = ( instructions... return_value )`
Haskell		`foo parameters = do Tab ↹instructions`	`foo parameters = return_value` o `foo parameters = do Tab ↹instructions Tab ↹return value`	`«main :: IO ()» main = do instructions`
Torre Eiffel	`foo («parameters»)`	`foo («parameters») require preconditions do instructions ensure postconditions end`	`foo («parameters»): type require preconditions do instructions Result := value ensure postconditions end`	^[b]
Script de café	`foo()`	`foo = ->`	`foo = -> value`	—
Script de café	`foo parameters`	`foo = () ->`	`foo = ( parameters ) -> value`	—
COBOL	`CALL "foo" «USING parameters» «exception-handling» «END-CALL»`^[d]	`«IDENTIFICATION DIVISION.» PROGRAM-ID. foo. «other divisions...» PROCEDURE DIVISION «USING parameters». instructions.`	`«IDENTIFICATION DIVISION.» PROGRAM-ID/FUNCTION-ID. foo. «other divisions...» DATA DIVISION. «other sections...» LINKAGE SECTION. «parameter definitions...» variable-to-return definition «other sections...» PROCEDURE DIVISION «USING parameters» RETURNING variable-to-return. instructions.`	—
COBOL	`«FUNCTION» foo«(«parameters»)»`	—		—

^a Pascal requiere "forward;" para declaraciones futuras .
^b Eiffel permite la especificación de la clase raíz y las características de una aplicación.
^c En Fortran, los parámetros de una función/subrutina se denominan argumentos (ya quePARAMETERes una palabra clave del lenguaje); laCALLpalabra clave es necesaria para las subrutinas.
^d En lugar de utilizar"foo", se puede utilizar una variable de cadena que contenga el mismo valor.

Conversiones de tipos

Where string is a signed decimal number:

	string to integer	string to long integer	string to floating point	integer to string	floating point to string
Ada^[1]	`Integer'Value (string_expression)`	`Long_Integer'Value (string_expression)`	`Float'Value (string_expression)`	`Integer'Image (integer_expression)`	`Float'Image (float_expression)`
ALGOL 68 with general, and then specific formats	With prior declarations and association of: `string buf := "12345678.9012e34 "; file proxy; associate(proxy, buf);`
	`get(proxy, ivar);`	`get(proxy, livar);`	`get(proxy, rvar);`	`put(proxy, ival);`	`put(proxy, rval);`
	`getf(proxy, ($g$, ivar));` or `getf(proxy, ($dddd$, ivar));`	`getf(proxy, ($g$, livar));` or `getf(proxy, ($8d$, livar));`	`getf(proxy, ($g$, rvar));` or `getf(proxy, ($8d.4dE2d$, rvar));`	`putf(proxy, ($g$, ival));` or `putf(proxy, ($4d$, ival));`	`putf(proxy, ($g(width, places, exp)$, rval));` or `putf(proxy, ($8d.4dE2d$, rval));`
APL	`⍎string_expression`	`⍎string_expression`	`⍎string_expression`	`⍕integer_expression`	`⍕float_expression`
C (C99)	`integer = atoi(string);`	`long = atol(string);`	`float = atof(string);`	`sprintf(string, "%i", integer);`	`sprintf(string, "%f", float);`
Objective-C	`integer = [string intValue];`	`long = [string longLongValue];`	`float = [string doubleValue];`	`string = [NSString stringWithFormat:@"%i", integer];`	`string = [NSString stringWithFormat:@"%f", float];`
C++ (STL)	`«std::»istringstream(string) >> number;`			`«std::»ostringstream o; o << number; string = o.str();`
C++11	`integer = «std::»stoi(string);`	`long = «std::»stol(string);`	`float = «std::»stof(string); double = «std::»stod(string);`	`string = «std::»to_string(number);`
C#	`integer = int.Parse(string);`	`long = long.Parse(string);`	`float = float.Parse(string);double = double.Parse(string);`	`string = number.ToString();`
D	`integer = std.conv.to!int(string)`	`long = std.conv.to!long(string)`	`float = std.conv.to!float(string)` `double = std.conv.to!double(string)`	`string = std.conv.to!string(number)`
Java	`integer = Integer.parseInt(string);`	`long = Long.parseLong(string);`	`float = Float.parseFloat(string);` `double = Double.parseDouble(string);`	`string = Integer.toString(integer);` `string = String.valueOf(integer);`	`string = Float.toString(float);` `string = Double.toString(double);`
JavaScript^[a]	`integer = parseInt(string);`		`float = parseFloat(string);` `float = new Number (string);` `float = Number (string);` `float = +string;`	`string = number.toString ();` `string = String (number);` `string = number+"";` string = `${number}`
Go	`integer, error = strconv.Atoi(string) integer, error = strconv.ParseInt(string, 10, 0)`	`long, error = strconv.ParseInt(string, 10, 64)`	`float, error = strconv.ParseFloat(string, 64)`	`string = strconv.Itoa(integer)` `string = strconv.FormatInt(integer, 10)` `string = fmt.Sprint(integer)`	`string = strconv.FormatFloat(float)` `string = fmt.Sprint(float)`
Rust^[d]	`string.parse::<i32>()` `i32::from_str(string)`	`string.parse::<i64>()` `i64::from_str(string)`	`string.parse::<f64>()` `f64::from_str(string)`	`integer.to_string()`	`float.to_string()`
Common Lisp	`(setf integer (parse-integer string))`		`(setf float (read-from-string string))`	`(setf string (princ-to-string number))`
Scheme	`(define number (string->number string))`			`(define string (number->string number))`
ISLISP	`(setf integer (convert string <integer>))`		`(setf float (convert string <float>))`	`(setf string (convert number <string>))`
Pascal	`integer := StrToInt(string);`		`float := StrToFloat(string);`	`string := IntToStr(integer);`	`string := FloatToStr(float);`
Visual Basic	`integer = CInt(string)`	`long = CLng(string)`	`float = CSng(string) double = CDbl(string)`	`string = CStr(number)`
Visual Basic .NET (can use both VB syntax above and .NET methods shown right)	`integer = Integer.Parse(string)`	`long = Long.Parse(string)`	`float = Single.Parse(string)` `double = Double.Parse(string)`	`string = number.ToString()`
Xojo	`integer = Val(string)`	`long = Val(string)`	`double = Val(string)` `double = CDbl(string)`	`string = CStr(number)` or `string = Str(number)`
Python	`integer = int(string)`	`long = long(string)`	`float = float(string)`	`string = str(number)`
S-Lang	`integer = atoi(string);`	`long = atol(string);`	`float = atof(string);`	`string = string(number);`
Fortran	`READ(string,format) number`			`WRITE(string,format) number`
PHP	`integer = intval(string);` or `integer = (int)string;`		`float = floatval(string);` `float = (float)string;`	`string = "$number";` or `string = strval(number);` or `string = (string)number;`
Perl^[b]	`number = 0 + string;`			`string = "number";`
Raku	`number = +string;`			`string = ~number;`
Ruby	`integer = string.to_i` or `integer = Integer(string)`		`float = string.to_f` `float = Float(string)`	`string = number.to_s`
Scala	`integer = string.toInt`	`long = string.toLong`	`float = string.toFloatdouble = string.toDouble`	`string = number.toString`
Smalltalk	`integer := Integer readFrom: string`		`float := Float readFrom: string`	`string := number asString`
Windows PowerShell	`integer = [int]string`	`long = [long]string`	`float = [float]string`	`string = [string]number;` or `string = "number";` or `string = (number).ToString()`
OCaml	`let integer = int_of_string string`		`let float = float_of_string string`	`let string = string_of_int integer`	`let string = string_of_float float`
F#	`let integer = int string`	`let integer = int64 string`	`let float = float string`	`let string = string number`
Standard ML	`val integer = Int.fromString string`		`val float = Real.fromString string`	`val string = Int.toString integer`	`val string = Real.toString float`
Haskell (GHC)	`number = read string`			`string = show number`
COBOL	`MOVE «FUNCTION» NUMVAL(string)^[c] TO number`			`MOVE number TO numeric-edited`

^a JavaScript only uses floating point numbers so there are some technicalities.^[7]
^b Perl doesn't have separate types. Strings and numbers are interchangeable.
^c NUMVAL-C or NUMVAL-F may be used instead of NUMVAL.
^ str::parse is available to convert any type that has an implementation of the std::str::FromStr trait. Both str::parse and FromStr::from_str return a Result that contains the specified type if there is no error. The turbofish (::<_>) on str::parse can be omitted if the type can be inferred from context.

Standard stream I/O

	read from	write to
	stdin	stdout	stderr
Ada^[1]	`Get (x)`	`Put (x)`	`Put (Standard_Error, x)`
ALGOL 68	`readf(($format$, x));` or `getf(stand in, ($format$, x));`	`printf(($format$, x));` or `putf(stand out, ($format$, x));`	`putf(stand error, ($format$, x));`^[a]
APL	`x←⎕`	`⎕←x`	`⍞←x`
C (C99)	`scanf(format, &x);` or `fscanf(stdin, format, &x);`^[b]	`printf(format, x);` or `fprintf(stdout, format, x);`^[c]	`fprintf(stderr, format, x);`^[d]
Objective-C	`data = [[NSFileHandle fileHandleWithStandardInput] readDataToEndOfFile];`	`[[NSFileHandle fileHandleWithStandardOutput] writeData:data];`	`[[NSFileHandle fileHandleWithStandardError] writeData:data];`
C++	`«std::»cin >> x;` or `«std::»getline(«std::»cin, str);`	`«std::»cout << x;`	`«std::»cerr << x;` or `«std::»clog << x;`
C#	`x = Console.Read();` or `x = Console.ReadLine();`	`Console.Write(«format, »x);` or `Console.WriteLine(«format, »x);`	`Console.Error.Write(«format, »x);` or `Console.Error.WriteLine(«format, »x);`
D	`x = std.stdio.readln()`	`std.stdio.write(x)` or `std.stdio.writeln(x)` or `std.stdio.writef(format, x)` or `std.stdio.writefln(format, x)`	`stderr.write(x)` or `stderr.writeln(x)` or `std.stdio.writef(stderr, format, x)` or `std.stdio.writefln(stderr, format, x)`
Java	`x = System.in.read();` or `x = new Scanner(System.in).nextInt();` or `x = new Scanner(System.in).nextLine();`	`System.out.print(x);` or `System.out.printf(format, x);` or `System.out.println(x);`	`System.err.print(x);` or `System.err.printf(format, x);` or `System.err.println(x);`
Go	`fmt.Scan(&x)` or `fmt.Scanf(format, &x)` or `x = bufio.NewReader(os.Stdin).ReadString('\n')`	`fmt.Println(x)` or `fmt.Printf(format, x)`	`fmt.Fprintln(os.Stderr, x)` or `fmt.Fprintf(os.Stderr, format, x)`
Swift	`x = readLine()` (2.x)	`print(x)` (2.x) `println(x)` (1.x)
JavaScript Web Browser implementation		`document.write(x)`
JavaScript Active Server Pages		`Response.Write(x)`
JavaScript Windows Script Host	`x = WScript.StdIn.Read(chars)` or `x = WScript.StdIn.ReadLine()`	`WScript.Echo(x)` or `WScript.StdOut.Write(x)` or `WScript.StdOut.WriteLine(x)`	`WScript.StdErr.Write(x)` or `WScript.StdErr.WriteLine(x)`
Common Lisp	`(setf x (read-line))`	`(princ x)` or `(format t format x)`	`(princ x error-output)` or `(format error-output format x)`
Scheme (R⁶RS)	`(define x (read-line))`	`(display x)` or `(format #t format x)`	`(display x (current-error-port))` or `(format (current-error-port) format x)`
ISLISP	`(setf x (read-line))`	`(format (standard-output) format x)`	`(format (error-output) format x)`
Pascal	`read(x);` or `readln(x);`	`write(x);` or `writeln(x);`	`write(stderr, x);` or `writeln(stderr, x);`
Visual Basic	`Input« prompt,» x`	`Print x` or `? x`	—
Visual Basic .NET	`x = Console.Read()` or `x = Console.ReadLine()`	`Console.Write(«format,»x)` or `Console.WriteLine(«format, »x)`	`Console.Error.Write(«format, »x)` or `Console.Error.WriteLine(«format, »x)`
Xojo	`x = StandardInputStream.Read()` or `x = StandardInputStreame.ReadLine()`	`StandardOutputStream.Write(x)` or `StandardOutputStream.WriteLine(x)`	`StdErr.Write(x)` or `StdErr.WriteLine(x)`
Python 2.x	`x = raw_input(«prompt»)`	`print x` or `sys.stdout.write(x)`	`print >> sys.stderr, x` or `sys.stderr.write(x)`
Python 3.x	`x = input(«prompt»)`	`print(x«, end=""»)`	`print(x«, end=""», file=sys.stderr)`
S-Lang	`fgets (&x, stdin)`	`fputs (x, stdout)`	`fputs (x, stderr)`
Fortran	`READ(*,format) variable names` or `READ(INPUT_UNIT,format) variable names`^[e]	`WRITE(*,format) expressions` or `WRITE(OUTPUT_UNIT,format) expressions`^[e]	`WRITE(ERROR_UNIT,format) expressions`^[e]
Forth	`buffer length ACCEPT ( # chars read ) KEY ( char )`	`buffer length TYPE char EMIT`	—
PHP	`$x = fgets(STDIN);` or `$x = fscanf(STDIN, format);`	`print x;` or `echo x;` or `printf(format, x);`	`fprintf(STDERR, format, x);`
Perl	`$x = <>;` or `$x = <STDIN>;`	`print x;` or `printf format, x;`	`print STDERR x;` or `printf STDERR format, x;`
Raku	`$x = $*IN.get;`	`x.print` or `x.say`	`x.note` or `$ERR.print(x)` or `$ERR.say(x)`
Ruby	`x = gets`	`puts x` or `printf(format, x)`	`$stderr.puts(x)` or `$stderr.printf(format, x)`
Windows PowerShell	`$x = Read-Host«« -Prompt» text»;` or `$x = [Console]::Read();` or `$x = [Console]::ReadLine()`	`x;` or `Write-Output x;` or `echo x`	`Write-Error x`
OCaml	`let x = read_int ()` or `let str = read_line ()` or `Scanf.scanf format (fun x ... -> ...)`	`print_int x` or `print_endline str` or `Printf.printf format x ...`	`prerr_int x` or `prerr_endline str` or `Printf.eprintf format x ...`
F#	`let x = System.Console.ReadLine()`	`printf format x ...` or `printfn format x ...`	`eprintf format x ...` or `eprintfn format x ...`
Standard ML	`val str = TextIO.inputLIne TextIO.stdIn`	`print str`	`TextIO.output (TextIO.stdErr, str)`
Haskell (GHC)	`x <- readLn` or `str <- getLine`	`print x` or `putStrLn str`	`hPrint stderr x` or `hPutStrLn stderr str`
COBOL	`ACCEPT x`	`DISPLAY x`

^a ALGOL 68 additionally as the "unformatted" transput routines: read, write, get, and put.
^b gets(x) and fgets(x, length, stdin) read unformatted text from stdin. Use of gets is not recommended.
^c puts(x) and fputs(x, stdout) write unformatted text to stdout.
^d fputs(x, stderr) writes unformatted text to stderr
^e INPUT_UNIT, OUTPUT_UNIT, ERROR_UNIT are defined in the ISO_FORTRAN_ENV module.^[15]

Reading command-line arguments

	Argument values	Argument counts	Program name / Script name
Ada^[1]	`Argument (n)`	`Argument_Count`	`Command_Name`
C (C99)	`argv[n]`	`argc`	first argument
Objective-C
C++
C#	`args[n]`	`args.Length`	`Assembly.GetEntryAssembly().Location;`
Java		`args.length`
D		`args.length`	first argument
JavaScript Windows Script Host implementation	`WScript.Arguments(n)`	`WScript.Arguments.length`	`WScript.ScriptName` or `WScript.ScriptFullName`
Go	`os.Args[n]`	`len(os.Args)`	first argument
Rust^[a]	`std::env::args().nth(n)` `std::env::args_os().nth(n)`	`std::env::args().count()` `std::env::args_os().count()`	`std::env::args().next()` `std::env::args_os().next()`
Swift	`Process.arguments[n]` or `Process.unsafeArgv[n]`	`Process.arguments.count` or `Process.argc`	first argument
Common Lisp	?	?	?
Scheme (R⁶RS)	`(list-ref (command-line) n)`	`(length (command-line))`	first argument
ISLISP	—	—	—
Pascal	`ParamStr(n)`	`ParamCount`	first argument
Visual Basic	`Command`^[b]	—	`App.Path`
Visual Basic .NET	`CmdArgs(n)`	`CmdArgs.Length`	`[Assembly].GetEntryAssembly().Location`
Xojo	`System.CommandLine`	(string parsing)	`Application.ExecutableFile.Name`
Python	`sys.argv[n]`	`len(sys.argv)`	first argument
S-Lang	`__argv[n]`	`__argc`	first argument
Fortran	`DO i = 1,argc CALL GET_COMMAND_ARGUMENT (i,argv(i)) ENDDO`	`argc = COMMAND_ARGUMENT_COUNT ()`	`CALL GET_COMMAND_ARGUMENT (0,progname)`
PHP	`$argv[n]`	`$argc`	first argument
Bash shell	`$n ($1, $2, $3, ...)` `$@` (all arguments)	`$#`	`$0`
Perl	`$ARGV[n]`	`scalar(@ARGV)`	`$0`
Raku	`@*ARGS[n]`	`@*ARGS.elems`	`$PROGRAM_NAME`
Ruby	`ARGV[n]`	`ARGV.size`	`$0`
Windows PowerShell	`$args[n]`	`$args.Length`	`$MyInvocation.MyCommand.Name`
OCaml	`Sys.argv.(n)`	`Array.length Sys.argv`	first argument
F#	`args.[n]`	`args.Length`	`Assembly.GetEntryAssembly().Location`
Standard ML	`List.nth (CommandLine.arguments (), n)`	`length (CommandLine.arguments ())`	`CommandLine.name ()`
Haskell (GHC)	`do { args <- System.getArgs; return length args !! n`}	`do { args <- System.getArgs; return length args`}	`System.getProgName`
COBOL	^[c]		—

^a In Rust, std::env::args and std::env::args_os return iterators, std::env::Args and std::env::ArgsOs respectively. Args converts each argument to a String and it panics if it reaches an argument that cannot be converted to UTF-8. ArgsOs returns a non-lossy representation of the raw strings from the operating system (std::ffi::OsString), which can be invalid UTF-8.
^b In Visual Basic, command-line arguments are not separated. Separating them requires a split function Split(string).
^c The COBOL standard includes no means to access command-line arguments, but common compiler extensions to access them include defining parameters for the main program or using ACCEPT statements.

Execution of commands

	Shell command	Execute program	Replace current program with new executed program
Ada^[1]	Not part of the language standard. Commonly done by compiler provided packages or by interfacing to C or POSIX.^[16]
C	`system("command");`		`execl(path, args);` or `execv(path, arglist);`
C++			`execl(path, args);` or `execv(path, arglist);`
Objective-C		`[NSTask launchedTaskWithLaunchPath:(NSString )path arguments:(NSArray )arguments];`
C#		`System.Diagnostics.Process.Start(path, argstring);`
F#		`System.Diagnostics.Process.Start(path, argstring);`
Go		`exec.Run(path, argv, envv, dir, exec.DevNull, exec.DevNull, exec.DevNull)`	`os.Exec(path, argv, envv)`
Visual Basic	`Interaction.Shell(command «, WindowStyle» «, isWaitOnReturn»)`
Visual Basic .NET	`Microsoft.VisualBasic.Interaction.Shell(command «, WindowStyle» «, isWaitOnReturn»)`	`System.Diagnostics.Process.Start(path, argstring)`
Xojo	`Shell.Execute(command «, Parameters»)`	`FolderItem.Launch(parameters, activate)`	—
D	`std.process.system("command");`		`std.process.execv(path, arglist);`
Java		`Runtime.exec(command);` or `new ProcessBuilder(command).start();`
JavaScript Windows Script Host implementation	`WScript.CreateObject ("WScript.Shell").Run(command «, WindowStyle» «, isWaitOnReturn»);`	`WshShell.Exec(command)`
Common Lisp	`(uiop:run-program command)`
Scheme	`(system command)`
ISLISP	—	—	—
Pascal	`system(command);`
OCaml	`Sys.command command, Unix.open_process_full command env (stdout, stdin, stderr),...`	`Unix.create_process prog args new_stdin new_stdout new_stderr, ...`	`Unix.execv prog args` or `Unix.execve prog args env`
Standard ML	`OS.Process.system command`	`Unix.execute (path, args)`	`Posix.Process.exec (path, args)`
Haskell (GHC)	`System.system command`	`System.Process.runProcess path args ...`	`Posix.Process.executeFile path True args ...`
Perl	`system(command)` or $output = `command` or `$output = qx(command)`		`exec(path, args)`
Ruby	`system(command)` or output = `command`		`exec(path, args)`
PHP	`system(command)` or $output = `command` or `exec(command)` or `passthru(command)`
Python	`os.system(command)` or `subprocess.Popen(command)`	`subprocess.call(["program", "arg1", "arg2", ...])`	`os.execv(path, args)`
S-Lang	`system(command)`
Fortran	`CALL EXECUTE_COMMAND_LINE (COMMAND «, WAIT» «, EXITSTAT» «, CMDSTAT» «, CMDMSG»)`^[a]
Windows PowerShell	`[Diagnostics.Process]::Start(command)`	`«Invoke-Item »program arg1 arg2 ...`
Bash shell	output=`command` or `output=$(command)`	`program arg1 arg2 ...`

^a Fortran 2008 or newer.^[17]

References

^ a b c d e f g h i j k l m n o p Ada Reference Manual – Language and Standard Libraries; ISO/IEC 8652:201x (E), "Reference Manual" (PDF). Archived from the original (PDF) on 2011-04-27. Retrieved 2013-07-19.
^ "Common Lisp HyperSpec (TM)". lispworks.com. Retrieved 30 January 2017.
^ "www.islisp.info: Specification". islisp.info. Archived from the original on 22 January 2016. Retrieved 30 January 2017.
^ a b "selected_int_kind in Fortran Wiki". fortranwiki.org. Retrieved 30 January 2017.
^ "Erlang — Types and Function Specifications". erlang.org. Retrieved 30 January 2017.
^ "Erlang — Advanced". erlang.org. Retrieved 30 January 2017.
^ a b 8.5 The Number Type
^ a b "selected_real_kind in Fortran Wiki". fortranwiki.org. Retrieved 30 January 2017.
^ "La biblioteca C de GNU: números complejos". gnu.org . Consultado el 30 de enero de 2017 .
^ "Gramática vb". Especificación del lenguaje Visual Basic . 17 de junio de 2016. Archivado desde el original el 29 de agosto de 2019. Consultado el 29 de agosto de 2019 .
^ "for...of". mozilla.org . Consultado el 30 de enero de 2017 .
^ "Try-Catch para VB". google.com . Archivado desde el original el 16 de abril de 2016. Consultado el 30 de enero de 2017 .
^ Klabnik, Steve; Nichols, Carol. "Manejo de errores". El lenguaje de programación Rust.
^ "Descomposición de números primos – Código Rosetta". rosettacode.org . Consultado el 30 de enero de 2017 .
^ "iso_fortran_env en Fortran Wiki". fortranwiki.org . Consultado el 30 de enero de 2017 .
^ "Ejecutar un comando del sistema – Código Rosetta". rosettacode.org . Consultado el 30 de enero de 2017 .
^ "EXECUTE_COMMAND_LINE – El compilador Fortran de GNU". gnu.org . Consultado el 30 de enero de 2017 .

[Ada_RM_2012-1] ^ a b c d e f g h i j k l m n o p Ada Reference Manual – Language and Standard Libraries; ISO/IEC 8652:201x (E), "Reference Manual" (PDF). Archived from the original (PDF) on 2011-04-27. Retrieved 2013-07-19.

[HyperSpec-2] "Common Lisp HyperSpec (TM)". lispworks.com. Retrieved 30 January 2017.

[Specification-3] "www.islisp.info: Specification". islisp.info. Archived from the original on 22 January 2016. Retrieved 30 January 2017.

[fortranwiki.org-4] "selected_int_kind in Fortran Wiki". fortranwiki.org. Retrieved 30 January 2017.

[5] "Erlang — Types and Function Specifications". erlang.org. Retrieved 30 January 2017.

[6] "Erlang — Advanced". erlang.org. Retrieved 30 January 2017.

[Javascript_numbers-7] 8.5 The Number Type

[ReferenceA-8] "selected_real_kind in Fortran Wiki". fortranwiki.org. Retrieved 30 January 2017.

[9] "La biblioteca C de GNU: números complejos". gnu.org . Consultado el 30 de enero de 2017 .

[10] "Gramática vb". Especificación del lenguaje Visual Basic . 17 de junio de 2016. Archivado desde el original el 29 de agosto de 2019. Consultado el 29 de agosto de 2019 .

[11] "for...of". mozilla.org . Consultado el 30 de enero de 2017 .

[12] "Try-Catch para VB". google.com . Archivado desde el original el 16 de abril de 2016. Consultado el 30 de enero de 2017 .

[13] Klabnik, Steve; Nichols, Carol. "Manejo de errores". El lenguaje de programación Rust.

[14] "Descomposición de números primos – Código Rosetta". rosettacode.org . Consultado el 30 de enero de 2017 .

[15] "iso_fortran_env en Fortran Wiki". fortranwiki.org . Consultado el 30 de enero de 2017 .

[Ada_Execute_Command-16] "Ejecutar un comando del sistema – Código Rosetta". rosettacode.org . Consultado el 30 de enero de 2017 .

[17] "EXECUTE_COMMAND_LINE – El compilador Fortran de GNU". gnu.org . Consultado el 30 de enero de 2017 .