Сравнение языков программирования (основные инструкции)

В этой статье сравнивается большое количество языков программирования путем составления таблиц их типов данных , выражений , операторов и синтаксисов объявлений , а также некоторых распространенных интерфейсов операционных систем.

Условные обозначения этой статьи

Обычно var , var или var — это то, как представляются имена переменных или другие нелитеральные значения, которые должен интерпретировать читатель. Остальное — буквенный код. Гильеметы ( «и ») заключают в себе необязательные разделы. Tab ↹указывает на необходимый (пробел) отступ.

Таблицы по умолчанию не отсортированы в лексикографическом порядке по названию языка программирования, и некоторые языки имеют записи в некоторых таблицах, но не в других.

Идентификаторы типов

Целые числа

	8 бит ( байт )		16 бит ( короткое целое )		32 бит		64 бит ( длинное целое )		Размер слова		Произвольно точный ( bignum )
	Подписано	Неподписанный	Подписано	Неподписанный	Подписано	Неподписанный	Подписано	Неподписанный	Подписано	Неподписанный	Произвольно точный ( bignum )
Ада ^[1]	`range -27 .. 27 - 1`^[дж]	`range 0 .. 28 - 1`^[дж] или `mod 28`^[к]	`range -215 .. 215 - 1`^[дж]	`range 0 .. 216 - 1`^[дж] или `mod 216`^[к]	`range -231 .. 231 - 1`^[дж]	`range 0 .. 232 - 1`^[дж] или `mod 232`^[к]	`range -263 .. 263 - 1`^[дж]	`mod 2**64`^[к]	`Integer`^[дж]	`range 0 .. 2**Integer'Size - 1`^[дж] или ^[к]`mod Integer'Size`	—
АЛГОЛ 68 (переменной ширины)	`short short int`^[с]	—	`short int`^[с]	—	`int`^[с]	—	`long int`^[с]	—	`int`^[с]	—	`long long int`^[а]^[г]
АЛГОЛ 68 (переменной ширины)	`short short int`^[с]	—	`short int`^[с]	—	`int`^[с]	—	`long int`^[с]	—	`bytes`и`bits`		`long long int`^[а]^[г]
C ( C99 фиксированной ширины)	`int8_t`	`uint8_t`	`int16_t`	`uint16_t`	`int32_t`	`uint32_t`	`int64_t`	`uint64_t`	`intptr_t`^[с]	`size_t`^[с]	—
C++ ( C++11 фиксированной ширины)	`int8_t`	`uint8_t`	`int16_t`	`uint16_t`	`int32_t`	`uint32_t`	`int64_t`	`uint64_t`	`intptr_t`^[с]	`size_t`^[с]
C ( переменная ширина C99 )	`signed char`	`unsigned char`	`short`^[с]	`unsigned short`^[с]	`long`^[с]	`unsigned long`^[с]	`long long`^[с]	`unsigned long long`^[с]	`int`^[с]	`unsigned int`^[с]
C++ ( C++11 переменная ширина)	`signed char`	`unsigned char`	`short`^[с]	`unsigned short`^[с]	`long`^[с]	`unsigned long`^[с]	`long long`^[с]	`unsigned long long`^[с]	`int`^[с]	`unsigned int`^[с]
Objective-C ( Cocoa )	`signed char`или`int8_t`	`unsigned char`или`uint8_t`	`short`или`int16_t`	`unsigned short`или`uint16_t`	`int`или`int32_t`	`unsigned int`или`uint32_t`	`long long`или`int64_t`	`unsigned long long`или`uint64_t`	`NSInteger`или`long`	`NSUInteger`или`unsigned long`
С#	`sbyte`	`byte`	`short`	`ushort`	`int`	`uint`	`long`	`ulong`	`IntPtr`	`UIntPtr`	`System.Numerics.BigInteger` (.NET 4.0)
Ява	`byte`	—	`short`	`char`^[б]	`int`	—	`long`	—	—	—	`java.math.BigInteger`
Идти	`int8`	`uint8`или`byte`	`int16`	`uint16`	`int32`	`uint32`	`int64`	`uint64`	`int`	`uint`	`big.Int`
Ржавчина	`i8`	`u8`	`i16`	`u16`	`i32`	`u32`	`i64`	`u64`	`isize`	`usize`	—
Быстрый	`Int8`	`UInt8`	`Int16`	`UInt16`	`Int32`	`UInt32`	`Int64`	`UInt64`	`Int`	`UInt`
Д	`byte`	`ubyte`	`short`	`ushort`	`int`	`uint`	`long`	`ulong`	—	—	`BigInt`
Общий Лисп ^[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`
Схема
ИСЛИСП ^[3]											`bignum`
Паскаль ( FPC )	`shortint`	`byte`	`smallint`	`word`	`longint`	`longword`	`int64`	`qword`	`integer`	`cardinal`	—
Визуальный базовый	—	`Byte`	`Integer`	—	`Long`	—	—		—		—
Visual Basic .NET	`SByte`	`Byte`	`Short`	`UShort`	`Integer`	`UInteger`	`Long`	`ULong`	—		`System.Numerics.BigInteger` (.NET 4.0)
FreeBasic	`Byte`или`Integer<8>`	`UByte`или`UInteger<8>`	`Short`или`Integer<16>`	`UShort`или`UInteger<16>`	`Long`или`Integer<32>`	`ULong`или`UInteger<32>`	`LongInt`или`Integer<64>`	`ULongInt`или`UInteger<64>`	`Integer`	`UInteger`	—
Питон 2.x	—		—		—		—		`int`	—	`long`
Питон 3.x	—		—		—		—		—		`int`
Сленг	—		—		—		—		—		—
Фортран	`INTEGER(KIND = n)`^[ф]	—	`INTEGER(KIND = n)`^[ф]	—	`INTEGER(KIND = n)`^[ф]	—	`INTEGER(KIND = n)`^[ф]	—
PHP	—		—		`int`^[м]	—	`int`^[м]	—	—		^[э]
Перл 5	— ^[д]		— ^[д]		— ^[д]		— ^[д]		— ^[д]		`Math::BigInt`
Раку	`int8`	`uint8`	`int16`	`uint16`	`int32`	`uint32`	`int64`	`uint64`	`Int`	—
Рубин	—		—		—		—		`Fixnum`	—	`Bignum`
Эрланг ^[сущ.]	—		—		—		—		`integer()`	—	`integer()`^[о]
Скала	`Byte`	—	`Short`	`Char`^[л]	`Int`	—	`Long`	—	—	—	`scala.math.BigInt`
Семя7	—	—	—	—	—	—	`integer`	—	—	—	`bigInteger`
Smalltalk	—		—		—		—		`SmallInteger`^[я]	—	`LargeInteger`^[я]
Windows PowerShell	—		—		—		—		—		—
OCaml	—		—		`int32`	—	`int64`	—	`int`или`nativeint`		`open Big_int;;`или`big_int`
Фа#	`sbyte`	`byte`	`int16`	`uint16`	`int32`или`int`	`uint32`	`int64`	`uint64`	`nativeint`	`unativeint`	`bigint`
Стандартный МЛ	—	`Word8.word`	—		`Int32.int`	`Word32.word`	`Int64.int`	`Word64.word`	`int`	`word`	`LargeInt.int`или `IntInf.int`
Хаскелл ( GHC )	`«import Int»`или`Int8`	`«import Word»`или`Word8`	`«import Int»`или`Int16`	`«import Word»`или`Word16`	`«import Int»`или`Int32`	`«import Word»`или`Word32`	`«import Int»`или`Int64`	`«import Word»`или`Word64`	`Int`	`«import Word»`или`Word`	`Integer`
Эйфелева	`INTEGER_8`	`NATURAL_8`	`INTEGER_16`	`NATURAL_16`	`INTEGER_32`	`NATURAL_32`	`INTEGER_64`	`NATURAL_64`	`INTEGER`	`NATURAL`	—
КОБОЛ ^[ч]	`BINARY-CHAR «SIGNED»`	`BINARY-CHAR UNSIGNED`	`BINARY-SHORT «SIGNED»`	`BINARY-SHORT UNSIGNED`	`BINARY-LONG «SIGNED»`	`BINARY-LONG UNSIGNED`	`BINARY-DOUBLE «SIGNED»`	`BINARY-DOUBLE UNSIGNED`	—	—	—
Математика	—		—		—		—		—		`Integer`
Язык Вольфрама	—		—		—		—		—		`Integer`

^a Стандартныеконстантыимогут использоваться для определения того, сколькоs иs можно с пользой добавить в качестве префикса ки. Фактические размеры,, идоступны в виде констант, , ит. д.int shortsint lengthsshortlongshort intlong intshort intintlong intshort max intmax intlong max int
^b Обычно используется для символов.
^c Языки ALGOL 68, C и C++ не определяют точную ширину целочисленных типовshort,int,long, и ( C99 , C++11 )long long, поэтому они зависят от реализации. В C и C++short,long, иlong longдолжны быть не менее 16, 32 и 64 бит соответственно, но могут быть и больше.intТип должен быть не менееshortи не болееlong, и обычно равен размеру слова на процессоре машины (т. е. на 32-битной машине он часто имеет ширину 32 бита; на 64-битных машинах он иногда имеет ширину 64 бита). C99 и C++11 ^{[ требуется ссылка ]} также определяют[u]intN_tтипы точной ширины в заголовке stdint.h . Для получения дополнительной информации см. Синтаксис C#Целочисленные типы . Кроме того, типыsize_tиptrdiff_tопределены в зависимости от размера адреса для хранения беззнаковых и знаковых целых чисел, достаточно больших для обработки индексов массива и разницы между указателями.
^d Perl 5 не имеет отдельных типов. Целые числа, числа с плавающей точкой, строки и т. д. считаются «скалярами».
^e PHP имеет две библиотеки произвольной точности. Библиотека BCMath использует только строки как тип данных. Библиотека GMP использует внутренний тип "ресурс".
^f ЗначениеnпредоставляетсяSELECTED_INT_KIND^{внутренней функцией [4]} .
^g Опция времени выполнения ALGOL 68 G--precision "number"может установить точность дляlong long ints до требуемого "числа" значащих цифр. Стандартные константыlong long int widthиlong long max intмогут использоваться для определения фактической точности.
^h COBOL позволяет указать требуемую точность и автоматически выберет доступный тип, способный представить указанную точность.PIC S9999Например, " " потребует знаковую переменную с точностью в четыре десятичных знака. Если указать как двоичное поле, то на большинстве платформ будет выбран 16-битный знаковый тип.
^i Smalltalk автоматически выбирает подходящее представление для целых чисел. Обычно присутствуют два представления: одно для целых чисел, соответствующих размеру исходного слова за вычетом любого бита тега ( SmallInteger ), и одно, поддерживающее целые числа произвольного размера ( LargeInteger ). Арифметические операции поддерживают полиморфные аргументы и возвращают результат в наиболее подходящем компактном представлении.
^j Типы диапазонов Ada проверяются на наличие нарушений границ во время выполнения (а также во время компиляции для статических выражений). Нарушения границ во время выполнения вызывают исключение «ошибка ограничения». Диапазоны не ограничиваются степенями двойки. Обычно предопределенными подтипами Integer являются: Positive (range 1 .. Integer'Last) и Natural (range 0 .. Integer'Last).Short_Short_Integer(8 бит),Short_Integer(16 бит) иLong_Integer(64 бита) также обычно предопределены, но не требуются стандартом Ada. Проверки во время выполнения можно отключить, если производительность важнее проверок целостности.
^k Модульные типы Ada реализуют модульную арифметику во всех операциях, т.е. нарушения диапазона невозможны. Модули не ограничены степенями двойки.
^l Обычно используется для символов, подобных char в Java.
^m int в PHP имеет ту же ширину, что иlongтип в C в этой системе.^[c]
^n Erlang является динамически типизированным. Идентификаторы типов обычно используются для указания типов полей записи, а также типов аргументов и возвращаемых значений функций.^[5]
^o Когда оно превышает одно слово.^[6]

С плавающей точкой

	Одинарная точность	Двойная точность	Другая точность	Зависит от процессора
Ада ^[1]	`Float`	`Long_Float`	—
АЛГОЛ 68	`real`^[а]	`long real`^[а]	`short real`, `long long real`, и т.д. ^[г]
С	`float`^[б]	`double`	`long double`^[ф]
С++ (STL)
Objective-C ( Cocoa )				`CGFloat`
С#	`float`		—
Ява	`float`
Идти	`float32`	`float64`
Ржавчина	`f32`	`f64`
Быстрый	`Float`или`Float32`	`Double`или`Float64`	`Float80`^[г]	`CGFloat`
Д	`float`	`double`		`real`
Общий Лисп	`single-float`	`double-float`	`float, short-float, long-float`
Схема
ИСЛИСП
Паскаль ( FPC )	`single`	`double`		`real`
Визуальный базовый	`Single`	`Double`	—
Visual Basic .NET
Ксоджо
Питон	—	`float`
JavaScript	—	`Number`^[7]	—
Сленг
Фортран	`REAL(KIND = n)`^[с]
PHP		`float`
Перл
Раку	`num32`	`num64`		`Num`
Рубин	—	`Float`	—
Скала	`Float`	`Double`
Семя7	—	`float`
Smalltalk	`Float`	`Double`
Windows PowerShell
OCaml	—	`float`	—
Фа#	`float32`	`float`
Стандартный МЛ	—			`real`
Хаскелл ( GHC )	`Float`	`Double`
Эйфелева	`REAL_32`	`REAL_64`
КОБОЛ	`FLOAT-BINARY-7`^[э]	`FLOAT-BINARY-34`^[э]	`FLOAT-SHORT`, `FLOAT-LONG`,`FLOAT-EXTENDED`
Математика	—	—		`Real`

^a Стандартныеконстантыимогут использоваться для определения того, сколькоs иs можно с пользой добавить в качестве префиксов ки. Фактические размеры, , идоступны в виде констант,ит. д. С константами,идоступны для каждого типа машинного эпсилона .real shortsreal lengthsshortlongshort reallong realshort realreallong realshort max realmax reallong max realshort small realsmall reallong small real
^b декларации одинарной точности часто не соблюдаются
^c ЗначениеnпредоставляетсяSELECTED_REAL_KIND^{внутренней функцией [8]} .
^d Опция времени выполнения ALGOL 68 G--precision "number"может установить точность дляlong long reals до требуемого "числа" значащих цифр. Стандартные константыlong long real widthиlong long max realмогут использоваться для определения фактической точности.
^e Эти типы с плавающей точкой IEEE будут введены в следующем стандарте COBOL.
^f Тот же размер, что иdoubleво многих реализациях.
^g Swift поддерживает 80-битный тип данных с плавающей точкой повышенной точности , эквивалентный типуlong doubleв языках C.

Комплексные числа

	Целое число	Одинарная точность	Двойная точность	Половинная и учетверенная точность и т.д.
Ада ^[1]	—	`Complex`^[б]	`Complex`^[б]	`Complex`^[б]
АЛГОЛ 68	—	`compl`	`long compl`и т. д.	`short compl`и т.д. и `long long compl`т.п.
С ( С99 ) ^[9]	—	`float complex`	`double complex`	—
С++ (STL)	—	`std::complex<float>`	`std::complex<double>`
С#	—	—	`System.Numerics.Complex` (.NET 4.0)
Ява	—	—	—
Идти	—	`complex64`	`complex128`
Д	—	`cfloat`	`cdouble`
Objective-C	—	—	—
Общий Лисп	(комплексное целое число)	(сложный однопоплавковый)	(сложный двойной поплавок)	сложный
Схема				—
Паскаль	—	—
Визуальный базовый	—	—
Visual Basic .NET	—	—	`System.Numerics.Complex` (.NET 4.0)
Перл			`Math::Complex`
Раку		`complex64`	`complex128`	`Complex`
Питон			`complex`	—
JavaScript	—	—
Сленг	—	—
Фортран		`COMPLEX(KIND = n)`^[а]
Рубин	`Complex`	—	`Complex`
Скала	—	—	—
Семя7	—	—	`complex`
Smalltalk	`Complex`	`Complex`	`Complex`
Windows PowerShell	—	—
OCaml	—	—	`Complex.t`
Фа#			`System.Numerics.Complex` (.NET 4.0)
Стандартный МЛ	—	—	—
Хаскелл ( GHC )	—	`Complex.Complex Float`	`Complex.Complex Double`
Эйфелева	—	—	—
КОБОЛ	—	—	—
Математика	`Complex`	—	—	`Complex`

^a ЗначениеnпредоставляетсяSELECTED_REAL_KIND^{внутренней функцией [8]} .
^b Универсальный тип, который может быть создан с использованием любого базового типа с плавающей точкой.

Другие типы переменных

	Текст		Булев	Перечисление	Объект / Универсальный
	Характер	Строка ^[а]	Булев	Перечисление	Объект / Универсальный
Ада ^[1]	`Character`	`String`, `Bounded_String`,`Unbounded_String`	`Boolean`	`(item₁, item₂, ...)`	`tagged null record`
АЛГОЛ 68	`char`	`string`,`bytes`	`bool`,`bits`	— - Определяется пользователем	—
С ( С99 )	`char`,`wchar_t`	—	`bool`^[б]	`enum «name» { item₁, item₂, ... };`	`void *`
С++ (STL)	`char`,`wchar_t`	`«std::»string`	`bool`^[б]		`void *`
Objective-C	`unichar`	`NSString *`	`BOOL`		`id`
С#	`char`	`string`	`bool`	`enum name { item₁« = value», item₂« = value», ... }`	объект
Ява	`char`	`String`	`boolean`	`enum name { item₁, item₂, ... }`	`Object`
Идти	`byte`,`rune`	`string`	`bool`	`const ( item₁ = iota item₂ ... )`	`interface{}`
Ржавчина	`char`	`String`	`bool`	`enum name { item₁« = value», item₂« = value», ... }`	`std::any::Any`
Быстрый	`Character`	`String`	`Bool`	`enum name { case item₁, item₂, ... }`	`Any`
Д	`char`	`string`	`bool`	`enum name { item₁, item₂, ... }`	`std.variant.Variant`
Общий Лисп	`character`	`string`	`boolean`	`(member item₁ item₂ ...)`	`t`
Схема
ИСЛИСП
Паскаль (ИСО)	`char`	—	`boolean`	`( item₁, item₂, ... )`	—
Объектный Паскаль ( Delphi )	`char`	`string`	`boolean`	`( item₁, item₂, ... )`	`variant`
Визуальный базовый	—	`String`	`Boolean`	`Enum name item₁ «= value» item₂ «= value» ... End Enum`	`[[Variant type\|Variant]]`
Visual Basic .NET	`Char`				`Object`
Ксоджо	—				`Object`или`Variant`
Питон	— ^[д]	`str`	`bool`	`from enum import Enum class Name(Enum): item₁ = value item₂ = value ...`	`object`
JavaScript	— ^[д]	`String`	`Boolean`		`Object`
Сленг
Фортран	`CHARACTER(LEN = *)`	`CHARACTER(LEN = :), allocatable`	`LOGICAL(KIND = n)`^[ф]		`CLASS(*)`
PHP	— ^[д]	`string`	`bool`		(декларация типа опущена)
Перл	— ^[д]				`UNIVERSAL`
Раку	`Char`	`Str`	`Bool`	`enum name<item₁ item₂ ...>` `enum name <<:item₁(value) :item₂(value) ..>>`	`Mu`
Рубин	— ^[д]	`String`	`Object`^[с]		`Object`
Скала	`Char`	`String`	`Boolean`	`object name extends Enumeration { val item₁, item₂, ... = Value }`	`Any`
Семя7	`char`	`string`	`boolean`	`const type: name is new enum item₁, item₂, ... end enum;`
Windows PowerShell
OCaml	`char`	`string`	`bool`	— ^[э]	—
Фа#				`type name = item₁ = value \|item₂ = value \| ...`	`obj`
Стандартный МЛ				— ^[э]	—
Хаскелл ( GHC )	`Char`	`String`	`Bool`	— ^[э]	—
Эйфелева	`CHARACTER`	`STRING`	`BOOLEAN`	—	`ANY`
КОБОЛ	`PIC X`	`PIC X(string length)`или`PIC X«X...»`	`PIC 1«(number of digits)»`или`PIC 1«1...»`	—	`OBJECT REFERENCE`
Математика	— ^[д]	`String`			—

^a в частности, строки произвольной длины и автоматически управляемые.
^b Этот язык представляет логическое значение как целое число, где false представлено значением ноль, а true — ненулевым значением.
^c Все значения оцениваются как истина или ложь. Все вTrueClassоценивается как истина, а все вFalseClassоценивается как ложь.
^d В этом языке нет отдельного типа символов. Символы представлены в виде строк длиной 1.
^e Перечисления в этом языке являются алгебраическими типами с конструкторами только с нулевым числом аргументов.
^f ЗначениеnпредоставляетсяSELECTED_INT_KIND^{внутренней функцией [4]} .

Производные типы

Множество

	массив фиксированного размера		динамический размер массива
	одномерный массив	многомерный массив	одномерный массив	многомерный массив
Ада ^[1]	`array (<first> .. <last>) of <type>` или `array (<discrete_type>) of <type>`	`array (<first₁> .. <last₁>, <first₂> .. <last₂>, ...) of <type>` или `array (<discrete_type₁>, <discrete_type₂>, ...) of <type>`	`array (<discrete_type> range <>) of <type>`	`array (<discrete_type₁> range <>, <discrete_type₂> range <>, ...) of <type>`
АЛГОЛ 68	`[first:last]«modename»` или просто: `[size]«modename»`	`[first₁:last₁, first₂:last₂]«modename»` или т.п. `[first₁:last₁][first₂:last₂]«modename»`	`flex[first:last]«modename»` или просто: `flex[size]«modename»`	`flex[first₁:last₁, first₂:last₂]«modename»` или `flex[first₁:last₁]flex[first₂:last₂]«modename» etc.`
С ( С99 )	`type name[size]`^[а]	`type name[size₁][size₂]`^[а]	`type *name` или внутри блока: `int n = ...; type name[n]`
С++ (STL)	`«std::»array<type, size>`(С++11)		`«std::»vector<type>`
С#	`type[]`	`type[,,...]`	`System.Collections.ArrayList` или `System.Collections.Generic.List<type>`
Ява	`type[]`^[б]	`type[][]...`^[б]	`ArrayList or ArrayList<type>`
Д	`type[size]`	`type[size₁][size₂]`	`type[]`
Идти	`[size]type`	`[size₁][size₂]...type`	`[]type`	`[][]type`
Ржавчина	`[type; size]`	`[[type; size₁]; size₂]`	`Vec<type>`	`Vec<Vec<type>>`
Быстрый			`[type]`или`Array<type>`	`[[type]]`или`Array<Array<type>>`
Objective-C	`NSArray`		`NSMutableArray`
JavaScript	—	—	`Array`^[г]
Общий Лисп	`(simple-array type (dimension))`	`(simple-array type (dimension1 dimension2))`	`(array type (dimension))`	`(array type (dimension1 dimension2))`
Схема
ИСЛИСП
Паскаль	`array[first..last] of type`^[с]	`array[first₁..last₁] of array[first₂..last₂] ... of type`^[с] или ^[с] `array[first₁..last₁, first₂..last₂, ...] of type`	—	—
Объектный Паскаль ( Delphi )	`array[first..last] of type`^[с]		`array of type`	`array of array ... of type`
Визуальный базовый	`Dim x(last) As type`	`Dim x(last₁, last₂,...) As type`
Visual Basic .NET	`type()`	`type(,,...)`	`System.Collections.ArrayList` или `System.Collections.Generic.List(Of type)`
Питон			`list`
Сленг	`x = type[size];`	`x = type[size₁, size₂, ...];`
Фортран	`type :: name(size)`	`type :: name(size₁, size₂,...)`	`type, ALLOCATABLE :: name(:)`	`type, ALLOCATABLE :: name(:,:,...)`
PHP			`array`
Перл
Раку			`Array[type] or Array of type`
Рубин		`x = Array.new(size₁){ Array.new(size₂) }`	`Array`
Скала	`Array[type]`	`Array[...[Array[type]]...]`	`ArrayBuffer[type]`
Семя7	`array type` или `array [idxType] type`	`array array type` или `array [idxType] array [idxType] type`	`array type` или `array [idxType] type`	`array array type` или `array [idxType] array [idxType] type`
Smalltalk	`Array`		`OrderedCollection`
Windows PowerShell	`type[]`	`type[,,...]`
OCaml	`type array`	`type array ... array`
Фа#	`type []` или `type array`	`type [,,...]`	`System.Collections.ArrayList` или `System.Collections.Generic.List<type>`
Стандартный МЛ	`type vector or type array`
Хаскелл ( GHC )	`x = Array.array (0, size-1) list_of_association_pairs`	`x = Array.array ((0, 0,...), (size₁-1, size₂-1,...)) list_of_association_pairs`
КОБОЛ	`level-number type OCCURS size «TIMES».`	определение одномерного массива...	`level-number type OCCURS min-size TO max-size «TIMES» DEPENDING «ON» size.`^[э]	—

^a В большинстве выражений (за исключениемsizeofи&) значения типов массивов в C автоматически преобразуются в указатель своего первого аргумента. См. Синтаксис C#Массивы для получения дополнительных сведений о синтаксисе и операциях с указателями.
^b Похожий на C форматtype x[]работает в Java, однакоtype[] xявляется предпочтительной формой объявления массива.
^c Поддиапазоны используются для определения границ массива.
^d Массив JavaScript — это особый вид объекта.
^e ПредложениеDEPENDING ONв COBOL не создает настоящий массив переменной длины и всегда выделяет максимальный размер массива.

Другие типы

	Простые составные типы		Алгебраические типы данных	Профсоюзы
	Записи	Выражение кортежа	Алгебраические типы данных	Профсоюзы
Ада ^[1]	`type name is «abstract» «tagged» «limited» [record field₁ : type; field₂ : type; ... end record \| null record]`	—	Любая комбинация записей, объединений и перечислений (а также ссылок на них, позволяющих использовать рекурсивные типы).	`type name (variation : discrete_type) is record case variation is when choice_list₁ => fieldname₁ : type; ... when choice_list₂ => fieldname₂ : type; ... ... end case; end record`
АЛГОЛ 68	`struct (modename «fieldname», ...);`	Требуемые типы и операторы могут быть определены пользователем.		`union (modename, ...);`
С ( С99 )	`struct «name» {type name;...};`	—	—	`union {type name;...};`
Objective-C	`struct «name» {type name;...};`	—
С++	`struct «name» {type name;...};`^[б]	`«std::»tuple<type₁..type_n>`
С#	`struct name {type name;...}`	`(val₁, val₂, ... )`		—
Ява	— ^[а]
JavaScript		—
Д	`struct name {type name;...}`		`std.variant.Algebraic!(type,...)`	`union {type name;...}`
Идти	`struct { «name» type ... }`
Ржавчина	`struct name {name: type, ...}`	`(val₁, val₂, ... )`	`enum name { Foo(types), ...}`	`union name {name: type, ...}`
Быстрый	`struct name { var name «: type» ... }`	`(«name₁:» val₁, «name₂:» val₂, «name₃:» val₃, ... )`	`enum name { case Foo«(types)» case Bar «(types)» ... }`
Общий Лисп	`(defstruct name slot-name (slot-name initial-value) (slot-name initial-value :type type) ...)`	`(cons val₁ val₂)`^[с]
Схема	—
ИСЛИСП
Паскаль	`record name: type; ... end`	—	—	`record case type of value: (types); ... end`
Визуальный базовый
Visual Basic .NET	`Structure name Dim name As type ... End Structure`	`(val₁, val₂, ... )`
Питон	— ^[а]	`«(»val₁, val₂, val₃, ... «)»`		—
Сленг	`struct {name [=value], ...}`
Фортран	`TYPE name type :: name ... END TYPE`
PHP	— ^[а]
Перл	— ^[д]			—
Раку	— ^[а]
Рубин	`OpenStruct.new({:name => value})`
Скала	`case class name(«var» name: type, ...)`	`(val₁, val₂, val₃, ... )`	`abstract class name case class Foo(«parameters») extends name case class Bar(«parameters») extends name ...` или или комбинация классов case и объектов case `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» \| ...`	—
Фа#	`type name = {«mutable» name : type;...}`	`«(»val₁, val₂, val₃, ... «)»`	`type name = Foo «of type» \| Bar «of type» \| ...`
Стандартный МЛ	`type name = {name : type,...}`	`(val₁, val₂, val₃, ... )`	`datatype name = Foo «of type» \| Bar «of type» \| ...`
Хаскелл	`data Name = Constr {name :: type,...}`	`(val₁, val₂, val₃, ... )`	`data Name = Foo «types» \| Bar «types» \| ...`
КОБОЛ	`level-number name type clauses. level-number+n name type clauses. ...`	—	—	`name REDEFINES variable type.`

^a Поддерживаются только классы.
^b struct в C++ на самом деле являются классами, но имеют публичную видимость по умолчанию итакже являются объектами POD . C++11 расширил это еще больше, чтобы заставить классы действовать идентично объектам POD во многих других случаях.
^c только пара
^d Хотя в Perl нет записей, поскольку система типов Perl допускает размещение различных типов данных в массиве, «хэши» (ассоциативные массивы), не имеющие переменного индекса, фактически будут тем же самым, что и записи.
^e Перечисления в этом языке являются алгебраическими типами с конструкторами только с нулевым числом аргументов.

Объявления переменных и констант

	переменная	постоянный	тип синоним
Ада ^[1]	`identifier : type« := initial_value»`^[э]	`identifier : constant type := final_value`	`subtype identifier is type`
АЛГОЛ 68	`modename name« := initial_value»;`	`modename name = value;`	`mode synonym = modename;`
С ( С99 )	`type name« = initial_value»;`	`enum{ name = value };`	`typedef type synonym;`
Objective-C		`enum{ name = value };`
С++		`const type name = value;`
С#	`type name₁« = initial_value», name₂« = initial_value», ...;` или `var name = initial_value;`	`const type name = value, name = value, ...;` или `readonly type name = value, name = value, ... ;`	`using synonym = type;`
Д	`type name« = initial_value»;` или `auto name = value;`	`const type name = value;` или `immutable type name = value;`	`alias type synonym;`
Ява	`type name« = initial_value»;`	`final type name = value;`	—
JavaScript	`var name« = initial_value»;`или (начиная с ECMAScript 2015) `let name« = initial_value»;`	`const name = value;`(начиная с ECMAScript 2015)	—
Идти	`var name type« = initial_value»` или `name := initial_value`	`const name «type» = value`	`type synonym type`
Ржавчина ^[ж]	`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;`
Быстрый	`var name «: type»« = initial_value»`	`let name «: type» = value`	`typealias synonym = type`
Общий Лисп	`(defparameter name initial-value)` или `(defvar name initial-value)`	`(defconstant name value)`	`(deftype synonym () 'type)`
Схема	`(define name initial_value)`
ИСЛИСП	`(defglobal name initial_value)` или `(defdynamic name initial_value)`	`(defconstant name value)`	—
Паскаль ^[а]	`name: type« = initial_value»`	`name = value`	`synonym = type`
Визуальный базовый	`Dim name «As type»`	См. примечания слева. Константы используют тот же синтаксис, а именно: использовать `Const`вместо`Dim` имеют ограничение только на определенные примитивные типы `Const name₁ «As type» = value, name₂ «As type» = value, ...`
Visual Basic .NET ^[10]	Синтаксис объявления переменных в VB.NET необычайно сложно точно описать. Учитывая, что существуют суффиксы идентификаторов («модификаторы»): `type_character`, доступен как альтернатива предложению `As`для некоторых примитивных типов данных; `nullable_specifier`; и `array_specifier`; и что a `modified_identifier`имеет вид `identifier«type_character»«nullable_specifier»«array_specifier»`; a `modified_identifier_list`— это разделенный запятыми список из двух или более вхождений `modified_identifier`; и a `declarator_list`— это список деклараторов, разделенных запятыми, который может иметь форму `identifier As object_creation_expression`(декларатор инициализатора объекта) , `modified_identifier «As non_array_type«array_rank_specifier»»« = initial_value»` (один заявитель) или `modified_identifier_list «As «non_array_type««array_rank_specifier»»` (множественный декларант); Допустимые операторы объявления имеют вид , где для целей семантического анализа необходимо преобразовать в список только отдельных деклараторов:`Dim declarator_listdeclarator_list` Пункты `As`каждого множественного декларатора распределены по его`modified_identifier_list` Декларатор инициализатора каждого объекта заменяется на`As New type...As type = New type...` и для которого, для каждого `identifier`, а `type_character`и `As`предложение не появляются одновременно; если `As`присутствует предложение, an `array_rank_specifier`не появляется одновременно как модификация идентификатора и типа предложения `As`; можно `unmodified_type`определить по правилу, что если присутствует предложение `type_character`«или» ,`As` `unmodified_type`это то, что указано такой конструкцией, и что в противном случае, либо `Option Infer`должен быть включен и `identifier`должен иметь инициализатор, в этом случае `unmodified_type`это инициализатор, или `Option Strict`должен быть выключен, в этом `unmodified_type`случае `Object`; его `final_type`добавляют `unmodified_type`перед его модификаторами; это `final_type`допустимый тип; и если `initial_value`присутствует, либо `Option Strict`включено и `initial_value`имеет расширяющееся преобразование в `final_type`, либо `Option Strict`выключен и `initial_value`имеет сужающее преобразование в `final_type`. Если `Option Explicit`выключено, переменные не требуют явного объявления; они объявляются неявно при использовании:`name = initial_value`		`Imports synonym = type`
Ксоджо	`Dim name «As type»« = initial_value»`		—
Питон	`name«: type» = initial_value`	—	`synonym = type`^[б]
CoffeeScript	`name = initial_value`	—
Сленг	`name = initial_value;`		`typedef struct {...} typename`
Фортран	`type :: name`	`type, PARAMETER :: name = value`
PHP	`$name = initial_value;`	`define("name", value); const name = value (5.3+)`	—
Перл	`«my» $name« = initial_value»;`^[с]	`use constant name => value;`	—
Раку	`«my «type»» $name« = initial_value»;`^[с]	`«my «type»» constant name = value;`	`::synonym ::= type`
Рубин	`name = initial_value`	`Name = value`	`synonym = type`^[б]
Скала	`var name«: type» = initial_value`	`val name«: type» = value`	`type synonym = type`
Windows PowerShell	`«[type]» $name = initial_value`	—	—
Оболочка Bash	`name=initial_value`	—	—
OCaml	`let name« : type ref» = ref value`^[г]	`let name «: type» = value`	`type synonym = type`
Фа#	`let mutable name «: type» = value`	`let name «: type» = value`
Стандартный МЛ	`val name «: type ref» = ref value`^[г]	`val name «: type» = value`
Хаскелл		`«name::type;» name = value`	`type Synonym = type`
Вперед	`VARIABLE name`(в некоторых системах вместо этого используйте)`value VARIABLE name`	`value CONSTANT name`
КОБОЛ	`level-number name type clauses.`	`«0»1 name CONSTANT «AS» value.`	`level-number name type clauses «IS» TYPEDEF.`
Математика	`name=initial_value`	—	—

^a Pascal имеет блоки объявлений. Смотрите функции.
^b Типы — это обычные объекты, поэтому вы можете просто назначать их.
^c В Perl ключевое слово «my» ограничивает область действия переменной блоком.
^d Технически, это не объявляет имя изменяемой переменной — в ML все имена могут быть связаны только один раз; вместо этого это объявляет имя указателем на «ссылочную» структуру данных, которая является простой изменяемой ячейкой. Затем структура данных может быть прочитана и записана с использованием!и:=соответственно.
^e Если начальное значение не указано, автоматически назначается недопустимое значение (что вызовет исключение времени выполнения, если оно будет использовано до назначения допустимого значения). Хотя такое поведение можно подавить, оно рекомендуется в интересах предсказуемости. Если для типа не может быть найдено недопустимое значение (например, в случае неограниченного целочисленного типа), вместо него выбирается допустимое, но предсказуемое значение.
^flet В Rust, если переменной или не задано начальное значениеlet mutи она никогда не присваивается позже, возникает предупреждение "неиспользуемая переменная". Если для переменной или не задано значениеconst,возникает ошибка. Для переменных, не являющихся заглавными, возникает ошибка "глобальные переменные не в верхнем регистре". После определения переменнаяstaticбытьприсвоена только вблоке или функции.static mutconststatic mutunsafe

Поток управления

Условныйзаявления

	если	иначе если	выберите случай	условное выражение
Ада ^[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 )` или `(case expression is when value_list₁ => expression₁ when value_list₂ => expression₂ ... «when others => expression_n» )`
Семя7	`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`
Модула-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`
АЛГОЛ 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 )`
АЛГОЛ 68 (краткая форма)	`( condition \| statements «\| statements» )`	`( condition \| statements \|: condition \| statements )`	`( variable \| statements,... «\| statements» )`
АПЛ	`: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}`
С ( С99 )	`if (condition) instructions «else instructions»` `instructions`может быть отдельным оператором или блоком в форме:`{ statements }`	`if (condition) instructions else if (condition) instructions ... «else instructions»` или `if (condition) instructions else { if (condition) instructions }`	`switch (variable) { case case1: instructions «; break;» ... «default: instructions» }`	`condition ? valueIfTrue : valueIfFalse`
Objective-C
С++ (STL)
Д
Ява
JavaScript
PHP
С#	`if (condition) instructions «else instructions»` `instructions`может быть отдельным оператором или блоком в форме:`{ 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» }` Все непустые случаи должны заканчиваться оператором `break`or `goto case`(то есть им не разрешается переходить в следующий случай). Случай `default`не обязательно должен быть последним.	`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 }»}`
Идти	`if condition {instructions} «else {instructions}»`	`if condition {instructions} else if condition {instructions} ... «else {instructions}»` или `switch { case condition: instructions ... «default: instructions» }`	`switch variable { case case₁: instructions ... «default: instructions» }`
Быстрый	`if condition {instructions} «else {instructions}»`	`if condition {instructions} else if condition {instructions} ... «else {instructions}»`	`switch variable { case case₁: instructions ... «default: instructions» }`
Перл	`if (condition) {instructions} «else {instructions}»` или `unless (notcondition) {instructions} «else {instructions}»`	`if (condition) {instructions} elsif (condition) {instructions} ... «else {instructions}»` или `unless (notcondition) {instructions} elsif (condition) {instructions} ... «else {instructions}»`	`use feature "switch"; ... given (variable) { when (case₁) { instructions } ... «default { instructions }» }`	`condition ? valueIfTrue : valueIfFalse`
Раку	`if condition {instructions} «else {instructions}»` или `unless notcondition {instructions}`	`if condition {instructions} elsif condition {instructions} ... «else {instructions}`	`given variable { when case₁ { instructions } ... «default { instructions }» }`	`condition ?? valueIfTrue !! valueIfFalse`
Рубин	`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`
Скала	`if (condition) {instructions} «else {instructions}»`	`if (condition) {instructions} else if (condition) {instructions} ... «else {instructions}»`	`expression match { case pattern1 => expression case pattern2 => expression ... «case _ => expression» }`^[б]	`if (condition) valueIfTrue else valueIfFalse`
Smalltalk	`condition ifTrue: trueBlock «ifFalse: falseBlock» end`			`condition ifTrue: trueBlock ifFalse: falseBlock`
Общий Лисп	`(when condition instructions)` или или `(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)` или `(cond (test1 value1) (test2 value2) ...))`
Схема	`(when condition instructions)` или `(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)`
ИСЛИСП	`(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)`
Паскаль	`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»`^[с]	`case variable of case1: instructions ... «else: instructions» end`^[с]
Визуальный базовый	`If condition Then instructions «Else instructions» End If` Однострочный, `instructions`когда :`instruction₁ : instruction₂ : ...` `If condition Then instructions «Else instructions»`	`If condition Then instructions ElseIf condition Then instructions ... «Else instructions» End If` Однострочный: см. примечание о языках типа C; `Else`предложение однострочного `If`оператора может содержать другой однострочный `If`оператор.	`Select« Case» variable Case case_pattern₁ instructions ... «Case Else instructions» End Select`	`IIf(condition, valueIfTrue, valueIfFalse)`
Visual Basic .NET				`If(condition, valueIfTrue, valueIfFalse)`
Ксоджо				`If(condition, valueIfTrue, valueIfFalse)`
Питон ^[а]	`if condition : Tab ↹instructions «else: Tab ↹instructions»`	`if condition : Tab ↹instructions elif condition : Tab ↹instructions ... «else: Tab ↹instructions»`	Питон 3.10+: `match variable: Tab ↹case case1: Tab ↹Tab ↹instructions Tab ↹case case2: Tab ↹Tab ↹instructions`	Питон 2.5+: `valueIfTrue if condition else valueIfFalse`
Сленг	`if (condition) { instructions } «else { instructions }»`	`if (condition) { instructions } else if (condition) { instructions } ... «else { instructions }»`	`switch (variable) { case case1: instructions } { case case2: instructions } ...`
Фортран	`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`
Вперед	`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»`^[б]	`if condition then valueIfTrue else valueIfFalse`
Фа#	Облегченный режим синтаксиса: Либо в одну строку, либо с отступом, как показано ниже: Режим подробного синтаксиса: такой же, как в стандартном ML.`if condition then Tab ↹instructions «else Tab ↹instructions»`	Режим облегченного синтаксиса: в одну строку или с отступом, как показано ниже: Режим подробного синтаксиса: такой же, как и в стандартном ML. `if condition then Tab ↹instructions elif condition then Tab ↹instructions ... «else Tab ↹instructions»`
Стандартный МЛ	`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»`^[б]
Хаскелл ( GHC )	`if condition then expression else expression` или или `when condition (do instructions)` `unless notcondition (do instructions)`	`result \| condition = expression \| condition = expression \| otherwise = expression`	`case value of { pattern1 -> expression; pattern2 -> expression; ... «_ -> expression» }`^[б]
Оболочка 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`
CoffeeScript	`if condition then expression «else expression»` или или или или `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»` или или `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` или `switch expression when condition expression «else expression»`	Все условия являются выражениями.
КОБОЛ	`IF condition «THEN» expression «ELSE expression».`^[г]		`EVALUATE expression «ALSO expression...» WHEN case-or-condition «ALSO case-or-condition...» expression ... «WHEN OTHER expression» END-EVALUATE`
Ржавчина	`if condition { expression }« else { expression }»`	`if condition { expression } else if condition { expression }« else { expression }»`	`match variable { pattern1 => expression, pattern2 => expression, pattern3 => expression, «_ => expression» }`^[^быть]	Все условия являются выражениями
	если	иначе если	выберите случай	условное выражение

^a Одна инструкция может быть записана на той же строке после двоеточия. Несколько инструкций группируются в блок , который начинается с новой строки (отступ обязателен). Синтаксис условного выражения не следует этому правилу.
^b Это сопоставление с образцом , похожее на select case, но не то же самое. Обычно используется для деконструкции алгебраических типов данных .
^c В языках семейства Паскаль точка с запятой не является частью оператора. Она является разделителем операторов, а не терминатором.
END-IFВместо точки в конце можно использовать ^d .
^e В Rust запятая (,) в конце ветви сопоставления может быть опущена после последней ветви сопоставления или после любой ветви сопоставления, в которой выражение является блоком (заканчивается возможно пустыми скобками сопоставления{}).

Циклические операторы

	цикл while	цикл do while	(контролируемый подсчет) цикл for	foreach
Ада ^[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` или ^[б] `(for [all \| some] [in \| of] [first .. last \| discrete_type \| iterator] => predicate)`
АЛГОЛ 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`
АЛГОЛ 68	`«while condition» do statements od`	`«while statements; condition» do statements od`	`«for index» «from first» «by increment» «to last» do statements od`
АПЛ	`:While condition statements :EndWhile`	`:Repeat statements :Until condition`	`:For var«s» :In list statements :EndFor`	`:For var«s» :InEach list statements :EndFor`
С ( С99 )	`instructions`может быть отдельным оператором или блоком в форме:`{ statements }` `while (condition) instructions`	`do instructions while (condition);`	`for («type» i = first; i <= last; i++) instructions`	—
Objective-C				`for (type item in set) instructions`
С++ (STL)				`«std::»for_each(start, end, function)` Начиная с C++11 : `for (type item : set) instructions`
С#				`foreach (type item in set) instructions`
Ява				`for (type item : set) instructions`
JavaScript			`for (var i = first; i <= last; i++) instructions`	Начиная с EcmaScript 2015: ^[11] `for (var item of set) instructions`
PHP			`foreach (range(first, last) as $i) instructions` или `for ($i = first; $i <= last; $i++) instructions`	`foreach (set as item) instructions` или `foreach (set as key => item) instructions`
Windows PowerShell			`for ($i = first; $i -le last; $i++) instructions`	`foreach (item in set) instructions`
Д			`foreach (i; first ... last) instructions`	`foreach («type» item; set) instructions`
Идти	`for condition { instructions }`		`for i := first; i <= last; i++ { instructions }`	`for key, item := range set { instructions }`
Быстрый	`while condition { instructions }`	2.х: 1.х: `repeat { instructions } while condition` `do { instructions } while condition`	`for i = first ... last { instructions }` или или `for i = first ..< last+1 { instructions }` `for var i = first; i <= last; i++ { instructions }`	`for item in set { instructions }`
Перл	`while (condition) { instructions }` или `until (notcondition) { instructions }`	`do { instructions } while (condition)` или `do { instructions } until (notcondition)`	`for«each» «$i» (first .. last) { instructions }` или `for ($i = first; $i <= last; $i++) { instructions }`	`for«each» «$item» (set) { instructions }`
Раку	`while condition { instructions }` или `until notcondition { instructions }`	`repeat { instructions } while condition` или `repeat { instructions } until notcondition`	`for first..last -> $i { instructions }` или `loop ($i = first; $i <=last; $i++) { instructions }`	`for set« -> $item» { instructions }`
Рубин	`while condition instructions end` или `until notcondition instructions end`	`begin instructions end while condition` или `begin instructions end until notcondition`	`for i in first..last instructions end` или или `for i in first...last+1 instructions end` `first.upto(last) { \|i\| instructions }`	`for item in set instructions end` или `set.each { \|item\| instructions }`
Оболочка Bash	`while condition ;do instructions done` или `until notcondition ;do instructions done`	—	`for ((i = first; i <= last; ++i)) ; do instructions done`	`for item in set ;do instructions done`
Скала	`while (condition) { instructions }`	`do { instructions } while (condition)`	`for (i <- first to last «by 1») { instructions }` или `first to last «by 1» foreach (i => { instructions })`	`for (item <- set) { instructions }` или `set foreach (item => { instructions })`
Smalltalk	`conditionBlock whileTrue: loopBlock`	`loopBlock doWhile: conditionBlock`	`first to: last do: loopBlock`	`collection do: loopBlock`
Общий Лисп	`(loop while condition do instructions)` или `(do () (notcondition) instructions)`	`(loop do instructions while condition)`	`(loop for i from first to last «by 1» do instructions)` или или `(dotimes (i N) instructions)` `(do ((i first (1+ i))) ((>=i last)) instructions)`	`(loop for item in list do instructions)` или или или или `(loop for item across vector do instructions)` `(dolist (item list) instructions)` `(mapc function list)` `(map type function sequence)`
Схема	`(do () (notcondition) instructions)` или `(let loop () (if condition (begin instructions (loop))))`	`(let loop () (instructions (if condition (loop))))`	`(do ((i first (+ i 1))) ((>= i last)) instructions)` или `(let loop ((i first)) (if (< i last) (begin instructions (loop (+ i 1)))))`	`(for-each (lambda (item) instructions) list)`
ИСЛИСП	`(while condition instructions)`	`(tagbody loop instructions (if condition (go loop))`	`(for ((i first (+ i 1))) ((>= i last)) instructions)`	`(mapc (lambda (item) instructions) list)`
Паскаль	`while condition do begin instructions end`	`repeat instructions until notcondition;`	`for i := first «step 1» to last do begin instructions end;`^[а]	`for item in set do instructions`
Визуальный базовый	`Do While condition instructions Loop` или или (Visual Basic .NET использует вместо этого) `Do Until notcondition instructions Loop` `While condition instructions WendEnd While`	`Do instructions Loop While condition` или `Do instructions Loop Until notcondition`	`i`необходимо объявить заранее. `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»`^[а]	`For Each item« As type» In set instructions Next« item»`
Ксоджо	`While condition instructions Wend`	`Do Until notcondition instructions Loop` или `Do instructions Loop Until notcondition`		`For Each item« As type» In set instructions Next« item»`
Питон	`while condition : Tab ↹instructions «else: Tab ↹instructions»`	—	Питон 3.x: Питон 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»`
Сленг	`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»`
Фортран	`DO WHILE (condition) instructions ENDDO`	`DO instructions IF (condition) EXIT ENDDO`	`DO I = first,last instructions ENDDO`	—
Вперед	`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` или `List.iter (fun item -> instructions) list`
Фа#	`while condition do Tab ↹instructions`	—	`for i = first to last do Tab ↹instructions`	`foritem in set do Tab ↹instructions` или `Seq.iter (fun item -> instructions) set`
Стандартный МЛ	`while condition do ( instructions )`	—		`Array.app (fn item => instructions) array` или `app (fn item => instructions) list`
Хаскелл ( GHC )	—		`Control.Monad.forM_ [first..last] (\i -> do instructions)`	`Control.Monad.forM_list (\item -> do instructions)`
Эйфелева	`from setup until condition loop instructions end`
CoffeeScript	`while condition expression` или или или или или `expression while condition` `while condition then expression` `until condition expression` `expression until condition` `until expression then condition`	—	`for i in [first..last] expression` или или `for i in [first..last] then expression` `expression for i in [first..last]`	`for item in set expression` или или `for item in set then expression` `expression for item in set`
КОБОЛ	`PERFORM procedure-1 «THROUGH procedure-2» ««WITH» TEST BEFORE» UNTIL condition`^[с] или `PERFORM ««WITH» TEST BEFORE» UNTIL condition expression END-PERFORM`	`PERFORM procedure-1 «THROUGH procedure-2» «WITH» TEST AFTER UNTIL condition`^[с] или `PERFORM «WITH» TEST AFTER UNTIL condition expression END-PERFORM`	`PERFORM procedure-1 «THROUGH procedure-2» VARYING i FROM first BY increment UNTIL i > last`^[д] или ^[д] `PERFORM VARYING i FROM first BY increment UNTIL i > last expression END-PERFORM`	—
Ржавчина	`while condition { expression }`	`loop { expression if condition { break; } }`	`for i in first..last+1 { expression }` или `for i in first..=last { expression }`	`for item in set { expression }`^[е] или ^[е] `set.into_iter().for_each(\|item\| expression);`

^a "stepn" используется для изменения интервала цикла. Если "step" опущено, то интервал цикла равен 1.
^b Это реализует квантификатор всеобщности («для всех» или «»), а также квантификатор существования («существует» или «»). $\forall$ $\exists$
THRUВместо можно использовать ^cTHROUGH .
«IS» GREATER «THAN»Вместо можно использовать ^d> .
^e Тип выражения множества должен реализовывать признакstd::iter::IntoIterator.

Исключения

	бросать	обработчик	утверждение
Ада ^[1]	`raise exception_name «with string_expression»`	`begin statements exception when exception_list₁ => statements; when exception_list₂ => statements; ... «when others => statements;» end`^[б]	`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`
АПЛ	`«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`
С ( С99 )	`longjmp(state, exception);`	`switch (setjmp(state)) { case 0: instructions break; case exception: instructions ... }`	`assert(condition);`
С++	`throw exception;`	`try { instructions } catch «(exception)» { instructions } ...`	`assert(condition);`
С#		`try { instructions } catch «(exception« name»)» { instructions } ... «finally { instructions }»`	`System.Diagnostics.Debug.Assert(condition);` или `System.Diagnostics.Trace.Assert(condition);`
Ява		`try { instructions } catch (exception) { instructions } ... «finally { instructions }»`	`assert condition «: description»;`
JavaScript		`try { instructions } catch (exception) { instructions} «finally { instructions }»`	?
Д		`try { instructions } catch (exception) { instructions } ... «finally { instructions }»`	`assert(condition);`
PHP		`try { instructions } catch (exception) { instructions } ... «finally { instructions }»`	`assert(condition);`
Сленг		`try { instructions } catch «exception» { instructions } ... «finally { instructions }»`	?
Windows PowerShell		`trap «[exception]» { instructions } ... instructions` или `try { instructions } catch «[exception]» { instructions } ... «finally { instructions }»`	`[Debug]::Assert(condition)`
Objective-C	`@throw exception;`	`@try { instructions } @catch (exception) { instructions } ... «@finally { instructions }»`	`NSAssert(condition, description);`
Быстрый	`throw exception`(2.х)	`do { try expression ... instructions } catch exception { instructions } ...`(2.х)	`assert(condition«, description»)`
Перл	`die exception;`	`eval { instructions }; if ($@) { instructions }`	?
Раку	`die exception;`	`try { instructions CATCH { when exception { instructions } ...}}`	?
Рубин	`raise exception`	`begin instructions rescue exception instructions ... «else instructions» «ensure instructions» end`
Smalltalk	`exception raise`	`instructionBlock on: exception do: handlerBlock`	`assert: conditionBlock`
Общий Лисп	`(error "exception")` или или `(error type arguments)` `(error (make-condition type arguments))`	`(handler-case (progn instructions) (exception instructions) ...)` или ^[а] `(handler-bind (condition (lambda instructions «invoke-restart restart args»)) ...)`	`(assert condition)` или или `(assert condition «(place) «error»»)` `(check-type var type)`
Схема ( R ⁶ RS )	`(raise exception)`	`(guard (con (condition instructions) ...) instructions)`	?
ИСЛИСП	`(error "error-string" objects)` или `(signal-condition condition continuable)`	`(with-handler handler form* )`	?
Паскаль	`raise Exception.Create()`	`try Except on E: exception do begin instructions end; end;`	?
Визуальный базовый	`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` '* Попробуйте класс * Частный mstrDescription As String Частный mlngNumber As Long Public Sub Catch () mstrDescription = Err . Описание mlngNumber = Err . Номер End Sub Открытое свойство Get Number () As Long Number = mlngNumber End Property Публичное свойство Получить описание () Как строковое описание = mstrDescription Конец свойства ^[12]	`Debug.Assert condition`
Visual Basic .NET	`Throw exception` или `Error errorcode`	`Try instructions Catch« name As exception»« When condition» instructions ... «Finally instructions» End Try`	`System.Diagnostics.Debug.Assert(condition)` или `System.Diagnostics.Trace.Assert(condition)`
Ксоджо	`Raise exception`	`Try instructions Catch «exception» instructions ... «Finally instructions» End Try`	—
Питон	`raise exception`	`try: Tab ↹instructions except «exception»: Tab ↹instructions ... «else: Tab ↹instructions» «finally: Tab ↹instructions»`	`assert condition`
Фортран	—
Вперед	`code THROW`	`xt CATCH ( code or 0 )`	—
OCaml	`raise exception`	`try expression with pattern -> expression ...`	`assert condition`
Фа#	`raise exception`	`try expression with pattern -> expression ...` или `try expression finally expression`	`assert condition`
Стандартный МЛ	`raise exception «arg»`	`expression handle pattern => expression ...`
Хаскелл ( GHC )	`throw exception` или `throwError expression`	`catch tryExpression catchExpression` или `catchError tryExpression catchExpression`	`assert condition expression`
КОБОЛ	`RAISE «EXCEPTION» exception`	`USE «AFTER» EXCEPTION OBJECT class-name.` или или или `USE «AFTER» EO class-name.` `USE «AFTER» EXCEPTION CONDITION exception-name «FILE file-name».` `USE «AFTER» EC exception-name «FILE file-name».`	—
Ржавчина	Нет ^[13]		`assert!(condition)`

^a Common Lisp позволяетwith-simple-restart,restart-caseиrestart-bindопределять перезапуски для использования сinvoke-restart. Необработанные условия могут привести к тому, что реализация покажет пользователю меню перезапусков перед тем, как развернуть стек.
^b Неперехваченные исключения распространяются на самое внутреннее динамически охватывающее выполнение. Исключения не распространяются между задачами (если только эти задачи в данный момент не синхронизированы в рандеву).

Другие операторы потока управления

	выходной блок (перерыв)	продолжать	этикетка	ветвь ( перейти )	возвращаемое значение от генератора
Ада ^[1]	`exit «loop_name» «when condition»`	—	`label:`	`goto label`	—
АЛГОЛ 68	`value exit;`...	`do statements; skip exit; label: statements od`	`label:`...	`go to label; ... goto label; ... label; ...`	`yield(value)` ( Обратный звонок ) ^[14]
АПЛ	`:Leave`	`:Continue`	`label:`	`→label` или `:GoTo label`	—
С ( С99 )	`break;`	`continue;`	`label:`	`goto label;`	—
Objective-C
С++ (STL)
Д
С#					`yield return value;`
Ява	`break «label»;`	`continue «label»;`		—
JavaScript	`break «label»;`	`continue «label»;`		—	`yield value«;»`
PHP	`break «levels»;`	`continue «levels»;`		`goto label;`	`yield «key =>» value;`
Перл	`last «label»;`	`next «label»;`
Раку	`last «label»;`	`next «label»;`
Идти	`break «label»`	`continue «label»`		`goto label`
Быстрый	`break «label»`	`continue «label»`		—
Оболочка Bash	`break «levels»`	`continue «levels»`	—	—	—
Общий Лисп	`(return)` или или `(return-from block)` `(loop-finish)`		`(tagbody tag ... tag ...)`	`(go tag)`
Схема
ИСЛИСП	`(return-from block)`		`(tagbody tag ... tag ...)`	`(go tag)`
Паскаль (ИСО)	—		`label:`^[а]	`goto label;`	—
Паскаль ( FPC )	`break;`	`continue;`	`label:`^[а]	`goto label;`
Визуальный базовый	`Exit block`В качестве альтернативы, для методов, `Return`	—	`label:`	`GoTo label`
Ксоджо		`Continue block`
Visual Basic .NET		`Continue block`			`Yield value`
Питон	`break`	`continue`	—		`yield value`
РПГ IV	`LEAVE;`	`ITER;`
Сленг	`break;`	`continue;`
Фортран	`EXIT`	`CYCLE`	`label`^[б]	`GOTO label`	—
Рубин	`break`	`next`
Windows PowerShell	`break «label»`	`continue`
OCaml	—
Фа#
Стандартный МЛ
Хаскелл ( GHC )
КОБОЛ	`EXIT PERFORM`или `EXIT PARAGRAPH`или `EXIT SECTION`или`EXIT.`	`EXIT PERFORM CYCLE`	`label «SECTION».`	`GO TO label`	—

^a Pascal имеет блоки объявлений. Смотрите функции.
Метка ^b должна быть числом от 1 до 99999.

Функции

См. рефлексивное программирование для вызова и объявления функций с помощью строк.

	вызов функции	базовая/пустая функция	функция возврата значения	требуемая основная функция
Ада ^[1]	`foo «(parameters)»`	`procedure foo «(parameters)» is begin statements end foo`	`function foo «(parameters)» return type is begin statements end foo`	—
АЛГОЛ 68	`foo «(parameters)»;`	`proc foo = «(parameters)» void: ( instructions );`	`proc foo = «(parameters)» rettype: ( instructions ...; retvalue );`	—
АПЛ	`«parameters» foo parameters`	`foo←{ statements }`	`foo←{ statements }`	—
С ( С99 )	`foo(«parameters»)`	`void foo(«parameters») { instructions }`	`type foo(«parameters») { instructions ... return value; }`	`«global declarations» int main(«int argc, char *argv[]») { instructions }`
Objective-C
С++ (STL)
Ява				`public static void main(String[] args) { instructions }` или `public static void main(String... args) { instructions }`
Д				`int main(«char[][] args») { instructions}` или или или `int main(«string[] args») { instructions}` `void main(«char[][] args») { instructions}` `void main(«string[] args») { instructions}`
С#		То же, что и выше; альтернативно, если только одно утверждение: `void foo(«parameters») => statement;`	То же, что и выше; альтернативно, если достаточно просто, чтобы быть выражением: `void foo(«parameters») => expression;`	`static void Main(«string[] args») method_body` Вместо этого может возвращать `int`. (начиная с C# 7.1:) Может возвращать `Task`или `Task<int>`, и если так, то может быть `async`.
JavaScript		`function foo(«parameters») { instructions }` или или `var foo = function («parameters») { instructions }` `var foo = new Function ("«parameter»", ..., "«last parameter»" "instructions");`	`function foo(«parameters») { instructions ... return value; }`	—
Идти		`func foo(«parameters») { instructions }`	`func foo(«parameters») type { instructions ... return value }`	`func main() { instructions }`
Быстрый		`func foo(«parameters») { instructions }`	`func foo(«parameters») -> type { instructions ... return value }`	—
Общий Лисп	`(foo «parameters»)`	`(defun foo («parameters») instructions)` или `(setf (symbol-function 'symbol) function)`	`(defun foo («parameters») ... value)`	—
Схема		`(define (foo parameters) instructions)` или `(define foo (lambda (parameters) instructions))`	`(define (foo parameters) instructions... return_value)` или `(define foo (lambda (parameters) instructions... return_value))`
ИСЛИСП		`(defun foo («parameters») instructions)`	`(defun foo («parameters») ... value)`
Паскаль	`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.`
Визуальный базовый	`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			То же, что и выше; альтернативно: `Function Foo«(parameters)»« As type» instructions Return value End Function` Предложение `As`не требуется, если `Option Strict`выключено. Вместо `As`предложения можно использовать символ типа. Если управление выходит из функции без явного указания возвращаемого значения, функция возвращает значение по умолчанию для возвращаемого типа.	`Sub Main(««ByVal »args() As String») instructions End Sub`или `Function Main(««ByVal »args() As String») As Integer instructions End Function`
Ксоджо
Питон	`foo(«parameters»)`	`def foo(«parameters»): Tab ↹instructions`	`def foo(«parameters»): Tab ↹instructions Tab ↹return value`	—
Сленг	`foo(«parameters» «;qualifiers»)`	`define foo («parameters») { instructions }`	`define foo («parameters») { instructions ... return value; }`	`public define slsh_main () { instructions }`
Фортран	`foo («arguments») CALL sub_foo («arguments»)`^[с]	`SUBROUTINE sub_foo («arguments») instructions END SUBROUTINE`^[с]	`type FUNCTION foo («arguments») instructions ... foo = value END FUNCTION`^[с]	`PROGRAM main instructions END PROGRAM`
Вперед	`«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; }`	—
Перл	`foo(«parameters»)` или `&foo«(parameters)»`	`sub foo { «my (parameters) = @_;» instructions }`	`sub foo { «my (parameters) = @_;» instructions... «return» value; }`
Раку	`foo(«parameters»)` или `&foo«(parameters)»`	`«multi »sub foo(parameters) { instructions }`	`«our «type» »«multi »sub foo(parameters) { instructions ... «return» value; }`
Рубин	`foo«(parameters)»`	`def foo«(parameters)» instructions end`	`def foo«(parameters)» instructions «return» value end`
Ржавчина	`foo(«parameters»)`	`fn foo(«parameters») { instructions }`	`fn foo(«parameters») -> type { instructions }`	`fn main() { instructions }`
Скала	`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 };` или `function foo { «param(parameters)» instructions }`	`function foo «(parameters)» { instructions ... return value };` или `function foo { «param(parameters)» instructions ... return value }`	—
Оболочка Bash	`foo «parameters»`	`function foo { instructions }` или `foo () { instructions }`	`function foo { instructions return «exit_code» }` или `foo () { instructions return «exit_code» }`
Оболочка Bash	`foo «parameters»`	параметры `$n`( $1 , $2 , $3 , ...) `$@`(все параметры) `$#`(количество параметров) `$0`(имя этой функции)
OCaml	`foo parameters`	`let «rec» foo parameters = instructions`	`let «rec» foo parameters = instructions... return_value`
Фа#		`let «rec» foo parameters = instructions`	`let «rec» foo parameters = instructions... return_value`	`[<EntryPoint>] let main args = instructions`
Стандартный МЛ		`fun foo parameters = ( instructions )`	`fun foo parameters = ( instructions... return_value )`
Хаскелл		`foo parameters = do Tab ↹instructions`	`foo parameters = return_value` или `foo parameters = do Tab ↹instructions Tab ↹return value`	`«main :: IO ()» main = do instructions`
Эйфелева	`foo («parameters»)`	`foo («parameters») require preconditions do instructions ensure postconditions end`	`foo («parameters»): type require preconditions do instructions Result := value ensure postconditions end`	^[б]
CoffeeScript	`foo()`	`foo = ->`	`foo = -> value`	—
CoffeeScript	`foo parameters`	`foo = () ->`	`foo = ( parameters ) -> value`	—
КОБОЛ	`CALL "foo" «USING parameters» «exception-handling» «END-CALL»`^[г]	`«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.`	—
КОБОЛ	`«FUNCTION» foo«(«parameters»)»`	—		—

^a Pascal требует "forward;" для предварительных объявлений .
^b Eiffel позволяет указать корневой класс и функцию приложения.
^c В Фортране параметры функции/подпрограммы называются аргументами (посколькуPARAMETER— ключевое слово языка);CALLключевое слово является обязательным для подпрограмм.
^d Вместо использования"foo"можно использовать строковую переменную, содержащую то же значение.

Преобразования типов

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.
^ "Библиотека GNU C: Комплексные числа". gnu.org . Получено 30 января 2017 г. .
^ "Grammar vb". Спецификация языка Visual Basic . 2016-06-17. Архивировано из оригинала 2019-08-29 . Получено 2019-08-29 .
^ "for...of". mozilla.org . Получено 30 января 2017 г. .
^ "Try-Catch for VB". google.com . Архивировано из оригинала 16 апреля 2016 года . Получено 30 января 2017 года .
^ Клабник, Стив; Николс, Кэрол. «Обработка ошибок». Язык программирования Rust.
^ "Prime decay – Rosetta Code". rosettacode.org . Получено 30 января 2017 г. .
^ "iso_fortran_env в Fortran Wiki". fortranwiki.org . Получено 30 января 2017 г. .
^ "Выполнить системную команду – Rosetta Code". rosettacode.org . Получено 30 января 2017 г. .
^ "EXECUTE_COMMAND_LINE – Компилятор GNU Fortran". gnu.org . Получено 30 января 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] "Библиотека GNU C: Комплексные числа". gnu.org . Получено 30 января 2017 г. .

[10] "Grammar vb". Спецификация языка Visual Basic . 2016-06-17. Архивировано из оригинала 2019-08-29 . Получено 2019-08-29 .

[11] "for...of". mozilla.org . Получено 30 января 2017 г. .

[12] "Try-Catch for VB". google.com . Архивировано из оригинала 16 апреля 2016 года . Получено 30 января 2017 года .

[13] Клабник, Стив; Николс, Кэрол. «Обработка ошибок». Язык программирования Rust.

[14] "Prime decay – Rosetta Code". rosettacode.org . Получено 30 января 2017 г. .

[15] "iso_fortran_env в Fortran Wiki". fortranwiki.org . Получено 30 января 2017 г. .

[Ada_Execute_Command-16] "Выполнить системную команду – Rosetta Code". rosettacode.org . Получено 30 января 2017 г. .

[17] "EXECUTE_COMMAND_LINE – Компилятор GNU Fortran". gnu.org . Получено 30 января 2017 г. .