Porovnání programovacích jazyků (základní pokyny) - Comparison of programming languages (basic instructions)

Tento článek porovnává velké množství programovací jazyky tabulkou jejich typy dat, jejich výraz, prohlášení, a prohlášení syntax a některá běžná rozhraní operačního systému.

Konvence tohoto článku

The tučně je doslovný kód. Non-bold je interpretován čtenářem. Prohlášení v guillemets («…») Jsou volitelné. Záložka ↹ označuje nezbytné odsazení (s mezerami).

Identifikátory typu

Celá čísla

	8 bitů (byte )		16 bitů (krátké celé číslo )		32 bitů		64 bitů (dlouhé celé číslo )		Velikost slova		Libovolně přesné (bignum )
	Podepsaný	Nepodepsaný	Podepsaný	Nepodepsaný	Podepsaný	Nepodepsaný	Podepsaný	Nepodepsaný	Podepsaný	Nepodepsaný	Libovolně přesné (bignum )
Ada^[1]	`rozsah -2 7 .. 2 7-1`^[j]	`rozsah 0 .. 2 8 - 1`^[j] nebo `mod 2 8`^[k]	`rozsah -2 15 .. 2 15 - 1`^[j]	`rozsah 0 .. 2 16 - 1`^[j] nebo `mod 2 16`^[k]	`rozsah -2 31 .. 2 31 - 1`^[j]	`rozsah 0 .. 2 32 - 1`^[j] nebo `mod 2 32`^[k]	`rozsah -2 63 .. 2 63-1`^[j]	`mod 2 ** 64`^[k]	`Celé číslo`^[j]	`rozsah 0 .. 2 ** Integer 'Velikost - 1`^[j] nebo `mod Integer 'Velikost`^[k]	N / A
ALGOL 68 (proměnná šířka)	`krátký krátký int`^[C]	N / A	`krátký int`^[C]	N / A	`int`^[C]	N / A	`dlouhá int`^[C]	N / A	`int`^[C]	N / A	`dlouhá dlouhá int` ^[A]^[G]
ALGOL 68 (proměnná šířka)	`krátký krátký int`^[C]	N / A	`krátký int`^[C]	N / A	`int`^[C]	N / A	`dlouhá int`^[C]	N / A	`bajtů` & `bity`		`dlouhá dlouhá int` ^[A]^[G]
C (C99 pevná šířka)	`int8_t`	`uint8_t`	`int16_t`	`uint16_t`	`int32_t`	`uint32_t`	`int64_t`	`uint64_t`	`intptr_t`^[C]	`size_t`^[C]	N / A
C ++ (C ++ 11 pevná šířka)	`int8_t`	`uint8_t`	`int16_t`	`uint16_t`	`int32_t`	`uint32_t`	`int64_t`	`uint64_t`	`intptr_t`^[C]	`size_t`^[C]
C (C99 variabilní šířka)	`podepsaný znak`	`nepodepsaný znak`	`krátký`^[C]	`bez znaménka krátký`^[C]	`dlouho`^[C]	`bez znaménka dlouho`^[C]	`dlouho dlouho`^[C]	`nepodepsáno dlouho dlouho`^[C]	`int`^[C]	`nepodepsané int`^[C]
C ++ (C ++ 11 variabilní šířka)	`podepsaný znak`	`nepodepsaný znak`	`krátký`^[C]	`bez znaménka krátký`^[C]	`dlouho`^[C]	`bez znaménka dlouho`^[C]	`dlouho dlouho`^[C]	`nepodepsáno dlouho dlouho`^[C]	`int`^[C]	`nepodepsané int`^[C]
Cíl-C (Kakao )	`podepsaný znak nebo int8_t`	`nepodepsaný znak nebo uint8_t`	`krátký nebo int16_t`	`bez znaménka krátký nebo uint16_t`	`int nebo int32_t`	`nepodepsané int nebo uint32_t`	`dlouho dlouho nebo int64_t`	`bez znaménka dlouho dlouho nebo uint64_t`	`NSInteger nebo dlouho`	`NSUInteger nebo bez znaménka dlouho`
C#	`sbyte`	`byte`	`krátký`	`ushort`	`int`	`uint`	`dlouho`	`dlouho`	`IntPtr`	`UIntPtr`	`System.Numerics.BigInteger` (.NET 4.0)
Jáva	`byte`	N / A	`krátký`	`char`^[b]	`int`	N / A	`dlouho`	N / A	N / A	N / A	`java.math.BigInteger`
Jít	`int8`	`uint8` nebo `byte`	`int16`	`uint16`	`int32`	`uint32`	`int64`	`uint64`	`int`	`uint`	`velký.Int`
Rez	`i8`	`u8`	`i16`	`u16`	`i32`	`u32`	`i64`	`u64`	`isize`	`využít`	N / A
Rychlý	`Int8`	`8. UInt`	`Int16`	`16. UInt`	`Int32`	`UInt32`	`Int64`	`UInt64`	`Int`	`UInt`
D	`byte`	`ubyte`	`krátký`	`ushort`	`int`	`uint`	`dlouho`	`dlouho`	N / A	N / A	`BigInt`
Společný Lisp^[2]	`(podepsaný bajt 8)`	`(nepodepsaný bajt 8)`	`(podepsaný bajt 16)`	`(nepodepsaný bajt 16)`	`(podepsaný bajt 32)`	`(nepodepsaný bajt 32)`	`(podepsaný bajt 64)`	`(nepodepsaný bajt 64)`			`bignum`
Systém
ISLISP^[3]											`bignum`
Pascal (FPC )	`zkratka`	`byte`	`smallint`	`slovo`	`Longint`	`dlouhé slovo`	`int64`	`qword`	`celé číslo`	`kardinál`	N / A
Visual Basic	N / A	`Byte`	`Celé číslo`	N / A	`Dlouho`	N / A	N / A		N / A		N / A
Visual Basic .NET	`SByte`	`Byte`	`Krátký`	`UShort`	`Celé číslo`	`UInteger`	`Dlouho`	`ULong`	N / A		`System.Numerics.BigInteger` (.NET 4.0)
FreeBasic	`Byte` nebo `Celé číslo <8>`	`UByte` nebo `UInteger <8>`	`Krátký` nebo `Celé číslo <16>`	`UShort` nebo `UInteger <16>`	`Dlouho` nebo `Celé číslo <32>`	`ULong` nebo `UInteger <32>`	`LongInt` nebo `Celé číslo <64>`	`ULONInt` nebo `UInteger <64>`	`Celé číslo`	`UInteger`	N / A
Krajta 2.x	N / A		N / A		N / A		N / A		`int`	N / A	`dlouho`
Python 3.x.	N / A		N / A		N / A		N / A		N / A		`int`
Slang	N / A		N / A		N / A		N / A		N / A		N / A
Fortran	`CELÉ ČÍSLO(KIND = n)`^[F]	N / A	`CELÉ ČÍSLO(KIND = n)`^[F]	N / A	`CELÉ ČÍSLO(KIND = n)`^[F]	N / A	`CELÉ ČÍSLO(KIND = n)`^[F]	N / A
PHP	N / A		N / A		`int` ^[m]	N / A	`int` ^[m]	N / A	N / A		^[E]
Perl 5	N / A^[d]		N / A^[d]		N / A^[d]		N / A^[d]		N / A^[d]		`Matematika :: BigInt`
Raku	`int8`	`uint8`	`int16`	`uint16`	`int32`	`uint32`	`int64`	`uint64`	`Int`	N / A
Rubín	N / A		N / A		N / A		N / A		`Fixnum`	N / A	`Bignum`
Erlang^[n]	N / A		N / A		N / A		N / A		celé číslo()	N / A	celé číslo()^[Ó]
Scala	`Byte`	N / A	`Krátký`	`Char`^[l]	`Int`	N / A	`Dlouho`	N / A	N / A	N / A	`scala.math.BigInt`
7. semeno	N / A	N / A	N / A	N / A	N / A	N / A	`celé číslo`	N / A	N / A	N / A	`bigInteger`
Pokec	N / A		N / A		N / A		N / A		`SmallInteger`^[i]	N / A	`LargeInteger`^[i]
Windows PowerShell	N / A		N / A		N / A		N / A		N / A		N / A
OCaml	N / A		N / A		`int32`	N / A	`int64`	N / A	`int nebo nativeint`		`otevřít Big_int ;; big_int`
F#	`sbyte`	`byte`	`int16`	`uint16`	`int32` nebo `int`	`uint32`	`int64`	`uint64`	`nativeint`	`unativeint`	`bigint`
Standardní ML	N / A	`Slovo 8. slovo`	N / A		`Int32.int`	`Word32.slovo`	`Int64.int`	`Word64.slovo`	`int`	`slovo`	`LargeInt.int` nebo `IntInf.int`
Haskell (GHC )	«`import Int`» `Int8`	«`importovat Word`» `Word8`	«`import Int`» `Int16`	«`importovat Word`» `Slovo16`	«`import Int`» `Int32`	«`importovat Word`» `Word32`	«`import Int`» `Int64`	«`importovat Word`» `Word64`	`Int`	«`importovat Word`» `Slovo`	`Celé číslo`
Eiffelova	`INTEGER_8`	`PŘÍRODNÍ_8`	`INTEGER_16`	`PŘÍRODNÍ_16`	`INTEGER_32`	`NATURAL_32`	`INTEGER_64`	`NATURAL_64`	`CELÉ ČÍSLO`	`PŘÍRODNÍ`	N / A
COBOL^[h]	`BINARY-CHAR «SIGNED»`	`BINARY-CHAR NEPODPÍSÁNO`	`BINARY-SHORT «PODPÍSÁNO»`	`BINARY-SHORT BEZ PODPISU`	`BINARY-LONG «SIGNED»`	`BINÁRNĚ DLOUHÉ NEPODPÍSÁNO`	`BINARY-DOUBLE «PODPÍSÁNO»`	`BINARY-DVOJNÁSOBKA NEPODPÍSANÁ`	N / A	N / A	N / A
Mathematica	N / A		N / A		N / A		N / A		N / A		`Celé číslo`
Wolfram jazyk	N / A		N / A		N / A		N / A		N / A		`Celé číslo`

^ a The Standard konstanty int šortky a délky int lze použít k určení, kolik 'krátký's a'dlouho„může být užitečně předponou“krátký int' a 'dlouhá int'. Skutečná velikostkrátký int', 'int' a 'dlouhá int'je k dispozici jako konstanty krátký max. int, max. int a dlouhá max. int atd.
^ b Běžně se používá pro znaky.
^ c Jazyky ALGOL 68, C a C ++ neurčují přesnou šířku celočíselných typů krátký, int, dlouho, a (C99, C ++ 11) dlouho dlouho, takže jsou závislé na implementaci. V C a C ++ krátký, dlouho, a dlouho dlouho typy musí mít šířku alespoň 16, 32 a 64 bitů, ale mohou být i větší. The int typ musí být alespoň tak široký jako krátký a nanejvýš tak široký jako dlouho, a je to obvykle šířka velikosti slova na procesoru stroje (tj. na 32bitovém stroji je často široký 32 bitů; na 64bitových strojích je někdy široký 64 bitů). C99 a C ++ 11^{[Citace je zapotřebí ]} také definovat [u] intN_t typy s přesnou šířkou v stdint.h záhlaví. VidětSyntaxe C # Integrální typy Pro více informací. Kromě toho typy size_t a ptrdiff_t jsou definovány ve vztahu k velikosti adresy, aby držely nepodepsaná a podepsaná celá čísla dostatečně velká pro zpracování indexů pole a rozdílu mezi ukazateli.
^ d Perl 5 nemá odlišné typy. Celá čísla, čísla s plovoucí desetinnou čárkou, řetězce atd. Jsou považována za „skaláry“.
^ e PHP má dvě knihovny s libovolnou přesností. Knihovna BCMath používá jako datový typ pouze řetězce. Knihovna GMP používá interní typ „prostředku“.
^ f Hodnota "n" je poskytována SELECTED_INT_KIND^[4] vnitřní funkce.
^ g ALGOL 68 Možnost spuštění G --přesnost „číslo“ lze nastavit přesnost pro dlouhá dlouhá ints na požadované „číslo“ významných číslic. The Standard konstanty dlouhá dlouhá int šířka a dlouhá dlouhá max. int lze použít ke stanovení skutečné přesnosti.
^ h COBOL umožňuje specifikaci požadované přesnosti a automaticky vybere dostupný typ schopný reprezentovat zadanou přesnost. "PIC S9999„například bude vyžadovat podepsanou proměnnou s přesností na čtyři desetinná místa. Pokud je zadáno jako binární pole, vybere se na většině platforem 16bitový podepsaný typ.
^ i Pokec automaticky vybere vhodné vyjádření pro integrální čísla. Obvykle jsou k dispozici dvě reprezentace, jedna pro celá čísla vyhovující velikosti nativního slova minus libovolný bit značky (SmallInteger) a jedna podporující celá čísla libovolné velikosti (LargeInteger). Aritmetické operace podporují polymorfní argumenty a vrátí výsledek v nejvhodnější kompaktní reprezentaci.
^ j Ada typy rozsahů jsou kontrolovány na porušení hranic za běhu (stejně jako v době kompilace pro statické výrazy). Porušení hranic za běhu vyvolá výjimku „chyba omezení“. Rozsahy nejsou omezeny na mocniny dvou. Běžně předdefinované celočíselné podtypy jsou: Pozitivní (rozsah 1 .. Celé číslo'poslední) a přírodní (rozsah 0 .. Celé číslo'poslední). Short_Short_Integer (8 bitů), Short_Integer (16 bitů) a Long_Integer (64 bitů) jsou také běžně předdefinovány, ale standard Ada to nevyžaduje. Kontroly doby běhu lze deaktivovat, pokud je výkon důležitější než kontroly integrity.
^ k Ada typy modulo implementují modulo aritmetiku ve všech operacích, tj. není možné porušení rozsahu. Moduly nejsou omezeny na mocniny dvou.
^ l Běžně se používá pro znaky jako Java char.
^ m int v PHP má stejnou šířku jako dlouho typ C má v tomto systému ^[C].
^ n Erlang se zadává dynamicky. Identifikátory typů se obvykle používají k určení typů polí záznamu a typů argumentů a návratů funkcí.^[5]
^ o Když překročí jedno slovo.^[6]

Plovoucí bod

	Jedna přesnost	Dvojitá přesnost	Jiná přesnost	Závisí na procesoru
Ada^[1]	`Plovák`	`Long_Float`	N / A
ALGOL 68	`nemovitý`^[A]	`dlouho skutečné`^[A]	`krátké skutečné`, `dlouho dlouho skutečné`, atd.^[d]
C	`plovák`^[b]	`dvojnásobek`	`dlouhý dvojitý`^[F]
C ++ (STL)
Objective-C (kakao)				`CGFloat`
C#	`plovák`		N / A
Jáva	`plovák`
Jít	`float32`	`float64`
Rez	`f32`	`f64`
Rychlý	`Plovák Float32`	`Dvojnásobek Float64`	`Float80`^[G]	`CGFloat`
D	`plovák`	`dvojnásobek`		`nemovitý`
Společný Lisp	`single-float`	`dvojitý plovák`	`float, short-float, long-float`
Systém
ISLISP
Pascal (Free Pascal)	`singl`	`dvojnásobek`		`nemovitý`
Visual Basic	`Singl`	`Dvojnásobek`	N / A
Visual Basic .NET
Xojo
Krajta	N / A	`plovák`
JavaScript	N / A	`Číslo`^[7]	N / A
Slang
Fortran	`SKUTEČNÉ (DRUHÉ = n)`^[C]
PHP		`plovák`
Perl
Raku	`num32`	`num64`		`Num`
Rubín	N / A	`Plovák`	N / A
Scala	`Plovák`	`Dvojnásobek`
7. semeno	N / A	`plovák`
Pokec	`Plovák`	`Dvojnásobek`
Windows PowerShell
OCaml	N / A	`plovák`	N / A
F#	`float32`	`plovák`
Standardní ML	N / A			`nemovitý`
Haskell (GHC)	`Plovák`	`Dvojnásobek`
Eiffelova	`REAL_32`	`REAL_64`
COBOL	`FLOAT-BINARY-7`^[E]	`FLOAT-BINARY-34`^[E]	`PLOCHÝ KRÁTKÝ`, `FLOAT-LONG`, `Plovák prodloužen`
Mathematica	N / A	N / A		`Nemovitý`

^ a The Standard konstanty skutečné šortky a skutečné délky lze použít k určení, kolik 'krátký's a'dlouho„může být užitečně předponou“krátké skutečné' a 'dlouho skutečné'. Skutečná velikostkrátké skutečné', 'nemovitý' a 'dlouho skutečné'je k dispozici jako konstanty krátké max. skutečné, max. skutečný a dlouhá max. skutečná atd. S konstantami krátké malé skutečné, malý skutečný a dlouhý malý skutečný k dispozici pro každý typ stroj epsilon.
^ b deklarace jediné přesnosti často nejsou dodržovány
^ c Hodnota "n" je poskytována SELECTED_REAL_KIND^[8] vnitřní funkce.
^ d ALGOL 68 Možnost spuštění G --přesnost „číslo“ lze nastavit přesnost pro dlouho dlouho skutečnés na požadované „číslo“ významných číslic. The Standard konstanty dlouhá dlouhá skutečná šířka a 'dlouhý dlouhý max skutečný lze použít ke stanovení skutečné přesnosti.
^ e Tyto typy IEEE s plovoucí desetinnou čárkou budou představeny v příštím standardu COBOL.
^ f Stejná velikost jako 'dvojnásobek„na mnoha implementacích.
^ g Swift podporuje 80-bit rozšířená přesnost typ s plovoucí desetinnou čárkou, ekvivalentní s plovoucí desetinnou čárkou dlouhý dvojitý v jazycích C.

Složitá čísla

	Celé číslo	Jedna přesnost	Dvojitá přesnost	Poloviční a čtyřnásobná přesnost atd.
Ada^[1]	N / A	`Komplex`^[b]	`Komplex`^[b]	`Komplex`^[b]
ALGOL 68	N / A	`kompl`	`dlouhý kompl` atd.	`krátké kompl` atd. & `dlouhý dlouhý kompl` atd.
C (C99) ^[9]	N / A	`plovoucí komplex`	`dvojitý komplex`	N / A
C ++ (STL)	N / A	`std :: complex`	`std :: complex`
C#	N / A	N / A	`System.Numerics.Complex` (.NET 4.0)
Jáva	N / A	N / A	N / A
Jít	N / A	`komplex64`	`komplex128`
D	N / A	`plovák`	`cdouble`
Cíl-C	N / A	N / A	N / A
Společný Lisp	(komplexní celé číslo)	(komplexní single-float)	(komplexní dvojitý plovák)	komplex
Systém				N / A
Pascal	N / A	N / A
Visual Basic	N / A	N / A
Visual Basic .NET	N / A	N / A	`System.Numerics.Complex` (.NET 4.0)
Perl			`Matematika :: Složité`
Raku		`komplex64`	`komplex128`	`Komplex`
Krajta			`komplex`	N / A
JavaScript	N / A	N / A
Slang	N / A	N / A
Fortran		`KOMPLEXNÍ (KIND = n)`^[A]
Rubín	`Komplex`	N / A	`Komplex`
Scala	N / A	N / A	N / A
7. semeno	N / A	N / A	`komplex`
Pokec	`Komplex`	`Komplex`	`Komplex`
Windows PowerShell	N / A	N / A
OCaml	N / A	N / A	`Complex.t`
F#			`System.Numerics.Complex` (.NET 4.0)
Standardní ML	N / A	N / A	N / A
Haskell (GHC)	N / A	`Complex.Complex Float`	`Complex.Complex Double`
Eiffelova	N / A	N / A	N / A
COBOL	N / A	N / A	N / A
Mathematica	`Komplex`	N / A	N / A	`Komplex`

^ a Hodnota "n" je poskytována SELECTED_REAL_KIND^[8] vnitřní funkce.

^ b Obecný typ, který lze vytvořit s jakýmkoli základním typem plovoucí desetinné čárky.

Jiné typy proměnných

	Text		Booleovský	Výčet	Objekt /Univerzální
	Charakter	Tětiva^[A]	Booleovský	Výčet	Objekt /Univerzální
Ada^[1]	`Charakter`	`Tětiva & Bounded_String & Unbounded_String`	`Booleovský`	`(položka₁, položka₂, ... )`	`označený nulový záznam`
ALGOL 68	`char`	`tětiva & bajtů`	`bool & bity`	N / A - Definováno uživatelem	N / A
C (C99)	`char wchar_t`	N / A	`bool`^[b]	`výčet "název" {položka₁, položka₂, ... };`	`prázdnota *`
C ++ (STL)	`char wchar_t`	`«Standardní ::»tětiva`	`bool`^[b]		`prázdnota *`
Cíl-C	`Unichar`	`NSString *`	`BOOL`		`id`
C#	`char`	`tětiva`	`bool`	`výčet název { položka₁« = hodnota», položka₂« = hodnota", ... }`	objekt
Jáva	`char`	`Tětiva`	`booleovský`	`výčet název {položka₁, položka₂, ... }`	`Objekt`
Jít	`byte runa`	`tětiva`	`bool`	`const (položka₁ = jota položka₂ ... )`	`rozhraní{}`
Rez	`char`	`Tětiva`	`bool`	`výčet název {položka₁, položka₂, ... }`	N / A
Rychlý	`Charakter`	`Tětiva`	`Boole`	`výčet název { případ položka₁, položka₂, ... }`	`Žádný`
D	`char`	`tětiva`	`bool`	`výčet název {položka₁, položka₂, ... }`	`standardní varianta`
Společný Lisp	`charakter`	`tětiva`	`booleovský`	`(členská položka₁ položka₂ ...)`	`t`
Systém
ISLISP
Pascal (ISO)	`char`	N / A	`booleovský`	`(položka₁, položka₂, ...)`	N / A
Objekt Pascal (Delphi)	`char`	`tětiva`	`booleovský`	`(položka₁, položka₂, ...)`	`varianta`
Visual Basic	N / A	`Tětiva`	`Booleovský`	`Výčet názevpoložka₁«= hodnota" položka₂« = hodnota" ... End Enum`	`Varianta`
Visual Basic .NET	`Char`				`Objekt`
Xojo	N / A				`Objekt nebo varianta`
Krajta	N / A^[d]	`str`	`bool`	`z enum import Enum jméno třídy(Výčet):položka₁ = hodnota položka₂ = hodnota ... # Python 3.4+`	`objekt`
JavaScript	N / A^[d]	`Tětiva`	`Booleovský`		`Objekt`
Slang
Fortran	`CHARAKTER (LEN = *)`	`CHARACTER (LEN = :), lze přiřadit`	`LOGICKÉ (DRUH = n)`^[F]		`TŘÍDA(*)`
PHP	N / A^[d]	`tětiva`	`bool`		(deklarace typu vynechána)
Perl	N / A^[d]				`UNIVERZÁLNÍ`
Raku	`Char`	`Str`	`Boole`	`výčet název 1 položka₂ ...> výčet název <<:položka₁(hodnota):položka₂(hodnota) .. >>`	`Mu`
Rubín	N / A^[d]	`Tětiva`	`Objekt`^[C]		`Objekt`
Scala	`Char`	`Tětiva`	`Booleovský`	`objekt název rozšiřuje výčet {val položka₁, položka₂, ... = Hodnota }`	`Žádný`
7. semeno	`char`	`tětiva`	`booleovský`	`typ const: název je nový výčet položka₁, položka₂, ... koncový výčet;`
Windows PowerShell
OCaml	`char`	`tětiva`	`bool`	N / A^[E]	N / A
F#				`typ název = položka₁ = hodnota \|položka₂ = hodnota \| ...`	`obj`
Standardní ML				N / A^[E]	N / A
Haskell (GHC)	`Char`	`Tětiva`	`Boole`	N / A^[E]	N / A
Eiffelova	`CHARAKTER`	`TĚTIVA`	`BOOLEAN`	N / A	`ŽÁDNÝ`
COBOL	`PIC X`	`PIC X (délka řetězce) nebo PIC X «X ...»`	`PIC 1 «(počet číslic)» nebo PIC 1 «1 ...»`	N / A	`REFERENČNÍ PŘEDMĚT`
Mathematica	N / A^[d]	`Tětiva`			N / A

^ a konkrétně řetězce libovolné délky a automaticky spravované.
^ b Tento jazyk představuje boolean jako celé číslo, kde false je reprezentováno jako hodnota nula a true nenulovou hodnotou.
^ c Všechny hodnoty se vyhodnotí na hodnotu true nebo false. Všechno dovnitř TrueClass hodnotí jako pravdivé a vše v FalseClass vyhodnotí jako nepravdivé.
^ d Tento jazyk nemá samostatný typ znaků. Znaky jsou reprezentovány jako řetězce délky 1.
^ e Výčty v tomto jazyce jsou algebraické typy pouze s nullovými konstruktory
^ f Hodnota "n" je poskytována SELECTED_INT_KIND^[4] vnitřní funkce.

Odvozené typy

Pole

	pole pevné velikosti		pole dynamické velikosti
	jednorozměrné pole	vícerozměrné pole	jednorozměrné pole	vícerozměrné pole
Ada^[1]	`pole (<first> .. <last>) z <type>` nebo `pole (<discrete_type>) z <type>`	`pole (1> .. 1>, 2> .. 2>, ...) z <type> nebo pole (1>, 2>, ...) z <type>`	`pole (<discrete_type> rozsah <>) z <type>`	`pole (1> rozsah <>, 2> rozsah <>, ...) z <type>`
ALGOL 68	`[za prvé:poslední]«Modename»` nebo jednoduše: `[velikost]«Modename»`	`[za prvé₁:poslední₁, za prvé₂:poslední₂]«Modename»` nebo `[za prvé₁:poslední₁][za prvé₂:poslední₂]«Modename»` atd.	`flex[za prvé:poslední]«Modename»` nebo jednoduše: `flex[velikost]«Modename»`	`flex[za prvé₁:poslední₁, za prvé₂:poslední₂]«Modename»` nebo `flex[za prvé₁:poslední₁]flex[za prvé₂:poslední₂]«Modename» atd.`
C (C99)	`zadejte název[velikost]^[A]`	`zadejte název[velikost₁][velikost₂]^[A]`	`typ *název` nebo v rámci bloku: `int n = ...; zadejte název[n]`
C ++ (STL)	`«Std ::» pole <typ, velikost>`(C ++ 11)		`«Std ::» vektor <typ>`
C#	`typ[]`	`typ[,,...]`	`Systém.Sbírky.ArrayList nebo Systém.Sbírky.Obecný.Seznam<typ>`
Jáva	`typ[]^[b]`	`typ[][]...^[b]`	`ArrayList nebo ArrayList <typ>`
D	`typ[velikost]`	`typ[velikost₁][velikost₂]`	`typ[]`
Jít	`[velikost]typ`	`[velikost₁][velikost₂]...typ`	`[]typ`	`[][]typ`
Rez	`[typ; velikost]`	`[[typ; velikost₁]; velikost₂]`	`Vec <typ>`	`Vec typ>>`
Rychlý			`[typ]` nebo `Pole <typ>`	`[[typ]]` nebo `Pole typ>>`
Cíl-C	`NSArray`		`NSMutableArray`
JavaScript	N / A	N / A	`Pole`^[d]
Společný Lisp	`(jednoduchý typ pole (dimenze))`	`(jednoduchý typ pole (rozměr₁ dimenze₂))`	`(typ pole (dimenze))`	`(typ pole (rozměr₁ dimenze₂))`
Systém
ISLISP
Pascal	`pole [za prvé..poslední] z typ^[C]`	`pole [za prvé₁..poslední₁] pole [za prvé₂..poslední₂] ... z typ ^[C]` nebo `pole [za prvé₁..poslední₁, za prvé₂..poslední₂, ...] z typ` ^[C]	N / A	N / A
Objekt Pascal (Delphi)	`pole [za prvé..poslední] z typ^[C]`		`pole typ`	`pole pole ... z typ`
Visual Basic
Visual Basic .NET	`typ()`	`typ(,,...)`	`Systém.Sbírky.ArrayList nebo Systém.Sbírky.Obecný.Seznam(Z typ)`
Krajta			`seznam`
Slang
Fortran	`typ :: název(velikost)`	`typ :: název(velikost₁, velikost₂,...)`	`typ, PŘIDĚLITELNÉ :: název(:)`	`typ, PŘIDĚLITELNÉ :: název(:,:,...)`
PHP			`pole`
Perl
Raku			`Pole [typ] nebo Pole typ`
Rubín			`Pole`
Scala	`Pole [typ]`	`Pole [...[Pole [typ]]...]`	`ArrayBuffer [typ]`
7. semeno	`pole typ nebo pole [idxType] typ`	`pole pole typ nebo pole [idxType] pole [idxType] typ`	`pole typ nebo pole [idxType] typ`	`pole pole typ nebo pole [idxType] pole [idxType] typ`
Pokec	`Pole`		`OrderedCollection`
Windows PowerShell	`typ[]`	`typ[,,...]`
OCaml	`typ pole`	`typ pole ... pole`
F#	`typ [] nebo zadejte pole`	`typ [,,...]`	`Systém.Sbírky.ArrayList nebo Systém.Sbírky.Obecný.Seznam<typ>`
Standardní ML	`typ vektor nebo zadejte pole`
Haskell (GHC)
COBOL	`typ čísla úrovně NACHÁZÍ se velikost «ČASY».`	`definice jednorozměrného pole ...`	`typ čísla úrovně NACHÁZÍ se minimální velikost NA maximální velikost «ČASY» ZÁVISÍCÍ «NA»Velikost.`^[E]	N / A

^ a Ve většině výrazů (kromě velikost a & operátory), hodnoty typů polí v C se automaticky převedou na ukazatel prvního argumentu. Vidět C syntaxe # pole pro další podrobnosti operací syntaxe a ukazatele.
^ b Typ C X[]„funguje však v Javě“[] X"je upřednostňovaná forma deklarace pole.
^ c Podrozsahy se používají k definování hranic pole.
^ d Pole JavaScriptu je speciální druh objektu.
^ e The ZÁLEŽÍ NA klauzule v COBOL nevytváří pole `` skutečné`` proměnné délky a vždy přidělí maximální velikost pole.

Jiné typy

	Jednoduché složené typy		Algebraické datové typy	Odbory
	Evidence	Tuple výraz	Algebraické datové typy	Odbory
Ada^[1]	`typ identifikátor je «abstraktní» «označeno» «omezený» [záznamnázev pole₁ : typ; název pole₂ : typ; ... konečný záznam \|nulový záznam]`	N / A	Libovolná kombinace záznamů, sjednocení a výčty (stejně jako odkazy na tyto, umožňující rekurzivní typy).	`typ identifikátor (variace : diskrétní_typ) je záznampřípad variace jekdyž choice_list₁ =>název pole₁ : typ; ... když choice_list₂ =>název pole₂ : typ; ... ... koncový případ; konečný záznam`
ALGOL 68	`struktur (modename «Polename», ...);`	Požadované typy a operátoři mohou být definované uživatelem		`svaz (modename, ...);`
C (C99)	`struktur "název" {zadejte název;...};`	N / A	N / A	`svaz {zadejte název;...};`
Cíl-C	`struktur "název" {zadejte název;...};`	N / A
C ++	`struktur "název" {zadejte název;...};^[b]`	`«Std ::» n-tice1..typ_n>`
C#	`struktur název {zadejte název;...}`	`(val₁, val₂, ... )`		N / A
Jáva	N / A^[A]
JavaScript		N / A
D	`struktur název {zadejte název;...}`		`standardní varianta. algebraické!(typ,...)`	`svaz {zadejte název;...}`
Jít	`struktura {«Název» typ ... }`
Rez	`název struktury {název: typ, ...}`	`(val₁, val₂, ... )`	`jméno výčtu { Foo(typy), ...}`	`název odboru {název: typ, ...}`
Rychlý	`struktur název {var název ": typ" ... }`	`("název₁:»Val₁, "název₂:»Val₂, "název₃:»Val₃, ... )`	`výčet název { případ Foo «(typy)» případ Bar "(typy)» ... }`
Společný Lisp	`(defstruct name slot-name (slot-name initial-value) (slot-name initial-value: type type) ...)`	`(nevýhody val₁ val₂)^[C]`
Systém	N / A
ISLISP
Pascal	`záznamnázev: typ; ... konec`	N / A	N / A	`záznampřípad typ z hodnota: (typy); ... konec`
Visual Basic
Visual Basic .NET	`Struktura název Ztlumit název Tak jako typ ... Koncová struktura`	`(val₁, val₂, ... )`
Krajta	N / A^[A]	`«(»Val₁, val₂, val₃, ... «)»`		N / A
Slang	`struktura {jméno [= hodnota], ...}`
Fortran	TYP název typ :: název ... KONEC TYPU
PHP	N / A^[A]
Perl	N / A^[d]			N / A
Raku	N / A^[A]
Rubín	`OpenStruct.Nový({:název => hodnota})`
Scala	`třída případů název(«var" název: typ, ...)`	`(val₁, val₂, val₃, ... )`	`abstraktní třída název třída případů Foo(«Parametry») rozšiřuje název třída případů Bar(«Parametry») rozšiřuje název ...` nebo `abstraktní třída název předmět případu Foo rozšiřuje název předmět případu Bar rozšiřuje název ...`nebo kombinace tříd případů a objektů případů
Windows PowerShell
OCaml	`typ název = {«proměnlivý" název : typ;...}`	`«(»Val₁, val₂, val₃, ... «)»`	`typ název = Foo «z typ" \| Bar "z typ" \| ...`	N / A
F#	`typ název = {«proměnlivý" název : typ;...}`	`«(»Val₁, val₂, val₃, ... «)»`	`typ název = Foo «z typ" \| Bar "z typ" \| ...`
Standardní ML	`typ název = {název : typ,...}`	`(val₁, val₂, val₃, ... )`	`datový typ název = Foo «z typ" \| Bar "z typ" \| ...`
Haskell	`data název = Constr {název :: typ,...}`	`(val₁, val₂, val₃, ... )`	`data název = Foo «typy» \| Tyčové «typy» \| ...`
COBOL	`klauzule typu název-úrovně. level-number + n klauzule typu name. ...`	N / A	N / A	`název REDEFINY proměnný typ.`

^ a Podporovány jsou pouze třídy.
^ b strukturs v C ++ jsou ve skutečnosti třídy, ale mají výchozí veřejnou viditelnost a jsou taky LUSK předměty. C ++ 11 to dále rozšířil, aby třídy v mnoha dalších případech fungovaly stejně jako objekty POD.
^ c pouze pár
^ d Ačkoli Perl nemá záznamy, protože Perlův systém typů umožňuje, aby byly v poli různé datové typy, „hash“ (asociativní pole), která nemají variabilní index, by byl ve skutečnosti stejný jako záznamy.
^ e Výčty v tomto jazyce jsou algebraické typy pouze s nullovými konstruktory

Proměnná a konstantní prohlášení

	proměnná	konstantní	zadejte synonymum
Ada^[1]	`identifikátor : typ":= počáteční hodnota"^[E]`	`identifikátor : konstantní typ := final_value`	`podtyp identifikátor je typ`
ALGOL 68	`modename název« := počáteční hodnota";`	`modename název = hodnota;`	`režimu synonymum = modename;`
C (C99)	`zadejte jméno «= počáteční hodnota";`	`výčet { název = hodnota };`	`typedef zadejte synonymum;`
Cíl-C		`výčet { název = hodnota };`
C ++		`konst zadejte název = hodnota;`
C#	`zadejte název₁« = initial_value », jméno₂« = počáteční hodnota", ... ; nebo var název = počáteční hodnota;`	`konst zadejte název = hodnota, název = hodnota, ... ; nebo pouze ke čtení zadejte název = hodnota, název = hodnota, ... ;`	`použitím synonymum = typ;`
D	`zadejte jméno «= počáteční hodnota"; nebo auto název = hodnota;`	`konst zadejte název = hodnota; nebo neměnný zadejte název = hodnota;`	`alias zadejte synonymum;`
Jáva	`zadejte jméno «= počáteční hodnota";`	`finále zadejte název = hodnota;`	N / A
JavaScript	`var název"= počáteční hodnota";` nebo `nechat název"= počáteční hodnota";` (od té doby ECMAScript 2015)	`konst název = hodnota;` (od té doby ECMAScript 2015)	N / A
Jít	`var typ jména «= initial_value »nebo název := počáteční hodnota`	`konst jméno «typ» = hodnota`	`typ typ synonyma`
Rez^[F]	`nechť mut název": typ""= počáteční hodnota";` `statický mut NÁZEV: typ = hodnota;`	`nechat název": typ""= počáteční hodnota";` `konst NÁZEV: typ = hodnota;` `statický NÁZEV: typ = hodnota;`	`typ synonymum = typename;`
Rychlý	`var název": typ""= počáteční hodnota"`	`nechat název ": typ" = hodnota`	`typealias synonymum = typ`
Společný Lisp	`(defparametr název počáteční hodnota) nebo (defvar.) název počáteční hodnota)`	`(v rozporu hodnota názvu)`	`(deftype synonymum () 'typ)`
Systém	`(definovat name initial_value)`
ISLISP	`(defglobální name initial_value) nebo (defdynamické name initial_value)`	`(v rozporu hodnota názvu)`	N / A
`Pascal^[A]`	`název: typ"= počáteční hodnota"`	`název = hodnota`	`synonymum = typ`
Visual Basic	`Ztlumit název "Tak jako typ"`	Viz poznámky vlevo. Konstanty používají stejnou syntaxi a: použití `Const` namísto `Ztlumit` mít omezení pouze na určité primitivní typy `Const název₁ «Tak jako typ" = hodnota, název₂ «Tak jako typ" = hodnota, ...`
Visual Basic .NET^[10]	Syntaxe deklarace proměnné VB.NET je překvapivě obtížné přesně popsat. Vzhledem k tomu, že existují přípony identifikátorů ("modifikátory"): `typ_charakter`, k dispozici jako alternativa k `Tak jako` klauzule pro některé primitivní datové typy; `nullable_specifier`; a `specifikátor pole`; a to A `modifikovaný_identifikátor` je ve formě `identifikátor «type_character» «nullable_specifier» «array_specifier»`; A `modified_identifier_list` je čárkou oddělený seznam dvou nebo více výskytů `modifikovaný_identifikátor`; a A `seznam deklarátorů` je seznam deklarantů oddělených čárkami, který může mít formu `identifikátor Tak jako výraz_vytvoření_objektu` (deklarátor inicializátoru objektu), `modified_identifier «Tak jako non_array_type «array_rank_specifier» »«= počáteční hodnota"` (jeden deklarant)nebo `upravený_identifikátor_list «Tak jako «Non_array_type« «array_rank_specifier» »` (vícenásobný deklarant); platné deklarační prohlášení mají formu `Ztlumit seznam deklarátorů`, kde pro účely sémantické analýzy převést `seznam deklarátorů` na seznam pouze jednotlivých deklarantů: The `Tak jako` klauzule každého z nich vícenásobný deklarant je distribuován přes jeho `modified_identifier_list` The `Jako nový typ...` každého deklarátor inicializátoru objektu je nahrazen `Tak jako typ = Nový typ...` a pro které, pro každého `identifikátor,` A `typ_charakter` a `Tak jako` klauzule se neobjevují oba; pokud `Tak jako` klauzule je k dispozici, an `array_rank_specifier` se neobjevuje jako modifikace identifikátoru, ani jako typ souboru `Tak jako` doložka; an `nemodifikovaný_typ` lze určit podle pravidla, že Pokud `typ_charakter` nebo `Tak jako` klauzule je k dispozici, `nemodifikovaný_typ` je to specifikováno takovým konstruktem, a to jinak, buď `Možnost Infer` musí být zapnuto a `identifikátor` musí mít inicializátor, v takovém případě `nemodifikovaný_typ` je to inicializátor, nebo `Možnost přísná` musí být vypnuto, v takovém případě `nemodifikovaný_typ` je `Objekt`; své `final_type` je jeho `nemodifikovaný_typ` před jeho modifikátory; své `final_type` je platný typ; a pokud `počáteční hodnota` je přítomen, buď `Možnost přísná` je zapnuto a `počáteční hodnota` má rozšiřující se převod na `final_type`nebo `Možnost přísná` je vypnuto a `počáteční hodnota` má zužující se převod na `final_type`. Li `Možnost Explicit` je vypnuto, proměnné nevyžadují výslovné prohlášení; při použití jsou deklarovány implicitně: `name = initial_value`		`Dovoz synonymum = typ`
Xojo	`Ztlumit název "Tak jako typ""= počáteční hodnota"`		N / A
Krajta	`název = počáteční hodnota`	N / A	`synonymum = typ^[b]`
CoffeeScript	`název = počáteční hodnota`	N / A	N / A
Slang	`název = počáteční hodnota;`		`typedef struct {...} typename`
Fortran	zadejte název	`typ, PARAMETR :: název = hodnota`
PHP	`$název = počáteční hodnota;`	`definovat("název", hodnota); konst název = hodnota (5,3+)`	N / A
Perl	`«můj» $název"= počáteční hodnota»;^[C]`	`používat konstantní název => hodnota;`	N / A
Raku	`«můj «Typ» »$ name«= počáteční hodnota»;^[C]`	`«můj "typ"" konstantní název = hodnota;`	`::synonymum ::= typ`
Rubín	`název = počáteční hodnota`	`název = hodnota`	`synonymum = typ^[b]`
Scala	`var název": typ" = počáteční hodnota`	`val název": typ" = hodnota`	`typ synonymum = typ`
Windows PowerShell	`«[typ] »$název = počáteční hodnota`	N / A	N / A
Bash shell	`jméno =počáteční hodnota`	N / A	N / A
OCaml	`nechat název": typ ref» = ref hodnota^[d]`	`nechat název ": typ" = hodnota`	`typ synonymum = typ`
F#	`nechat měnitelné název": typ" = hodnota`	`nechat název ": typ" = hodnota`
Standardní ML	`val název": typ ref» = ref hodnota^[d]`	`val název ": typ" = hodnota`
Haskell		`"název::typ;" název = hodnota`	`typ Synonymum = typ`
Forth	`VARIABILNÍ název` (v některých systémech použít `hodnota VARIABILNÍ název` namísto)	`hodnota KONSTANTNÍ název`
COBOL	`klauzule typu název typu číslo.`	`«0»1 název KONSTANTNÍ «TAK JAKO»Hodnota.`	`klauzule typu název typu číslo úrovně «JE» TYPEDEF.`
Mathematica	`jméno =počáteční hodnota`	N / A	N / A

^ a Pascal má deklarační bloky. Vidět Porovnání programovacích jazyků (základní pokyny) #Functions.
^ b Typy jsou jen běžné objekty, takže je můžete jednoduše přiřadit.
^ c V Perlu klíčové slovo „moje“ nastavuje rozsah proměnné do bloku.
^ d Technicky to nedeklaruje název být proměnlivou proměnnou - v ML mohou být všechna jména svázána pouze jednou; spíše prohlašuje název ukázat na „referenční“ datovou strukturu, což je jednoduchá proměnlivá buňka. Datovou strukturu lze poté číst a zapisovat pomocí ! a := operátoři, resp.
^ e Pokud není zadána žádná počáteční hodnota, je automaticky přiřazena neplatná hodnota (která spustí výjimku za běhu, pokud byla použita před přiřazením platné hodnoty). I když lze toto chování potlačit, doporučuje se to v zájmu předvídatelnosti. Pokud pro typ nelze najít neplatnou hodnotu (například v případě celočíselného typu bez omezení), je místo toho vybrána platná, přesto předvídatelná hodnota.
^ f V Rust, pokud není dána počáteční hodnota a nechat nebo nechť mut proměnná a nikdy se jí nepřiřadí, existuje "nepoužitá proměnná" varování. Pokud není uvedena žádná hodnota pro a konst nebo statický nebo statický mut proměnná, došlo k chybě. Tady je „globály bez velkých písmen“ chyba pro velká písmena konst proměnné. Poté, co je definováno, a statický mut proměnnou lze přiřadit pouze v nebezpečný blok nebo funkce.

Řízení toku

Podmiňovací způsob prohlášení

	-li	jinak pokud	vyberte případ	podmíněný výraz
Ada^[1]	`-li stav pak prohlášení «jiný prohlášení » skončit, pokud`	`-li stav₁ pak prohlášení elsif stav₂ pak prohlášení ... «jiný prohlášení » skončit, pokud`	`případ výraz jekdyž seznam_hodnoty₁ => prohlášení když seznam_hodnoty₂ => prohlášení ...«když ostatní => prohlášení » koncový případ`	`(li stav₁ pak výraz₁ «elsif stav₂ pak výraz₂» ... jiný výraz_n ) (případ výraz je když seznam_hodnoty₁ => výraz₁ když seznam_hodnoty₂ => výraz₂ ... «když ostatní => výraz_n» )`
7. semeno	`-li stav pak prohlášení «jiný prohlášení » skončit, pokud`	`-li stav₁ pak prohlášení elsif stav₂ pak prohlášení ... «jiný prohlášení » skončit, pokud`	`případ výraz z když set1 : prohlášení ... «v opačném případě: prohlášení » koncový případ`
Modula-2	`-li stav pak prohlášení «jiný prohlášení » konec`	`-li stav₁ pak prohlášení elsif stav₂ pak prohlášení ... «jiný prohlášení » konec`	`případ výraz z caseLabelList : prohlášení \| ... «jiný prohlášení » konec`
ALGOL 68	`-li stav pak prohlášení «jiný prohlášení » fi`	`-li stav pak prohlášení elif stav pak prohlášení fi`	`případ přepínač v prohlášení, prohlášení «, ... ven prohlášení » esac`	(podmínka \| valueIfTrue \| valueIfFalse)
ALGOL 68 (krátký formulář)	(podmínka \| výpisy «\| výpisy»)	(podmínka \| prohlášení \|: podmínka \| prohlášení)	(proměnná \| výpisy, ... «\| výpisy»)
APL	`:Li stav instrukce «:Jiný instrukce" : Konec`	`:Li stav instrukce : ElseIf stav instrukce ... «:Jiný instrukce" : Konec`	`:Vybrat výraz :Případ případ1 instrukce ... «:Jinýinstrukce" : EndSelect`	`{stav:valueIfTrue ⋄ valueIfFalse}`
C (C99) a: Cíl-C C ++ (STL) D Jáva JavaScript PHP	`pokud (stav) instrukce «jiný instrukce"` `instrukce` může to být jediný příkaz nebo blok ve formě: `{ prohlášení }`	`pokud (stav) instrukce jinak pokud (stav) instrukce ... «jiný instrukce"` `pokud (stav) instrukce` `else {if (stav) instrukce }`	`přepínač (proměnná) {případ případ1: instrukce «přestávka;» ... «výchozí: instrukce" }`	`stav ? valueIfTrue : valueIfFalse`
C#	`pokud (stav) instrukce «jiný instrukce"` `instrukce` může to být jediný příkaz nebo blok ve formě: `{ prohlášení }`	`pokud (stav) instrukce «jiný instrukce"` `pokud (stav) instrukce jinak pokud (stav) instrukce ... «jiný instrukce"`	Všechny neprázdné případy musí končit a `přestávka` nebo `běžný případ` prohlášení (to znamená, že se nesmí dostat do dalšího případu). The `výchozí` případ není nutný jako poslední.	`stav ? valueIfTrue : valueIfFalse` `přepínač (proměnná)` `{` `případ případ₁:` `instrukce` `«Break_or_jump_statement» ... «výchozí:` `instrukce` `break_or_jump_statement »` `}`
Windows PowerShell	`pokud (stav) instrukce «jiný instrukce"`	`pokud (stav) { instrukce } elseif (stav) { instrukce } ... «else { instrukce }»`	`přepínač (proměnná) { případ1 { instrukce «přestávka;» } ... «výchozí { instrukce }»}`
Jít	`-li stav {instrukce} «else {instrukce}»`	`-li stav {instrukce} jinak pokud stav {instrukce} ... «else {instrukce}» nebo přepnout {případ stav: instrukce ... «výchozí: instrukce" }`	`přepínač proměnná {případ případ1: instrukce ... «výchozí: instrukce" }`
Rychlý	`-li stav {instrukce} «else {instrukce}»`	`-li stav {instrukce} jinak pokud stav {instrukce} ... «else {instrukce}»`	`přepínač proměnná {případ případ1: instrukce ... «výchozí: instrukce" }`
Perl	`pokud (stav) {instrukce} «else {instrukce}» nebo pokud (podmínka) {instrukce} «else {instrukce}»`	`pokud (stav) {instrukce} elsif (stav) {instrukce} ... «else {instrukce}» nebo pokud (podmínka) {instrukce} elsif (stav) {instrukce} ... «else {instrukce}»`	`použít funkci „switch“; ... dané (proměnná) {když (případ1) { instrukce } ... «výchozí { instrukce }» }`	`stav ? valueIfTrue : valueIfFalse`
Raku	`-li stav {instrukce} «else {instrukce}» nebo ledaže podmínka {instrukce}`	`-li stav {instrukce} elsif stav {instrukce} ... «else {instrukce}`	`daný proměnná {když případ1 { instrukce } ... «výchozí { instrukce }» }`	`stav ?? valueIfTrue !! valueIfFalse`
Rubín	`-li stav instrukce «jiný instrukce"`	`-li stav instrukce elsif stav instrukce ... «jiný instrukce" konec`	`případ proměnná když případ1 instrukce ... «jinýinstrukce" konec`	`stav ? valueIfTrue : valueIfFalse`
Scala	`pokud (stav) {instrukce} «else {instrukce}»`	`pokud (stav) {instrukce} jinak pokud (stav) {instrukce} ... «else {instrukce}»`	`výraz zápas {případ vzor1 => výraz případ vzor2 => výraz ... «případ _ => výraz" }^[b]`	`pokud (stav) valueIfTrue jiný valueIfFalse`
Pokec	`stav ifTrue: trueBlock «ifFalse: falseBlock » konec`			`stav ifTrue: trueBlock ifFalse: falseBlock`
Společný Lisp	`(když stav instrukce) nebo (pokud stav instrukce) nebo (li stav (progn instrukce) «(progn instrukce)»)`	`(kond (podmínka1 pokyny) (podmínka2 pokyny) ... «(t instrukce)»)`	`(případ výraz(instrukce case1) (pokyny case2) ... «(v opačném případě instrukce)»)`	`(li test pak jinde)` `(podmínka (test1 hodnota1) (test2 hodnota2) ...))`
Systém	`(když pokyny k podmínkám) nebo (li stav (začít instrukce) «(začít instrukce)»)`	`(kond (podmínka1 pokyny) (podmínka2 pokyny) ...«(jiný instrukce)»)`	`(případ (proměnná) ((případ1) instrukce) ((případ2) instrukce) ...«(jiný instrukce)»)`	`(li podmínka valueIfTrue valueIfFalse)`
ISLISP	`(li stav (progn instrukce) «(progn instrukce)»)`	`(kond (podmínka1 pokyny) (podmínka2 pokyny) ... «(t instrukce)»)`	`(případ výraz(instrukce case1) (pokyny case2) ... «(t instrukce)»)`	`(li podmínka valueIfTrue valueIfFalse)`
Pascal	`-li stav pak začít instrukce konec «jinak začítinstrukce konec»^[C]`	`-li stav pak začít instrukce konec jinak pokud stav pak začítinstrukce konec ... «jinak začítinstrukce konec»^[C]`	`případ proměnná z případ1: instrukce ... «jiný: instrukce" konec^[C]`
Visual Basic	`Li stav Pak instrukce «Jiný instrukce" Konec, pokud` Jednořádkový: Pokud to necháme `instrukce` být: `prohlášení : prohlášení : ...` `Li stav Pak instrukce"Jiný instrukce"`	`Li stav Pakinstrukce Jinak Pokud stav Pakinstrukce ... «Jiný instrukce" Konec, pokud` Jednořádkový: Viz poznámka o jazycích podobných C; the `Jiný` klauzule jednořádkové `Li` výpis může obsahovat další jednořádkový `Li` prohlášení.	`Vybrat« Případ»ProměnnáPřípad case_pattern ₁instrukce ... «Případ jinýinstrukce" Ukončit výběr`	`IIf (stav, valueIfTrue, valueIfFalse)`
Visual Basic .NET				`Li(stav, valueIfTrue, valueIfFalse)`
Xojo				`Li(stav, valueIfTrue, valueIfFalse)`
Krajta ^[A]	`-li stav : Záložka ↹ instrukce «jiný: Záložka ↹ instrukce"`	`-li stav : Záložka ↹ instrukce elif stav : Záložka ↹ instrukce ... «jiný: Záložka ↹ instrukce"`		`valueIfTrue -li stav jiný valueIfFalse` (Python 2.5+)
Slang	`pokud (stav) { instrukce } «else { instrukce }»`	`pokud (stav) { instrukce } else if (stav) { instrukce } ... «else { instrukce }»`	`přepínač (proměnná) { případ případ1: instrukce } { případ případ2: instrukce } ...`
Fortran	`IF (stav) PAK instrukce JINÝ instrukce ENDIF`	`IF (stav) PAK instrukce ELSEIF (stav) PAK instrukce ... JINÝ instrukce ENDIF`	`VYBERTE PŘÍPAD (proměnná) PŘÍPAD (případ1) instrukce ... VÝCHOZÍ PŘÍPAD instrukce KONEC VÝBĚRU`
Forth	`stav LI instrukce « JINÝ instrukce" PAK`	`stav LI instrukce JINÝ stav LI instrukce POTOM POTOM`	`hodnota PŘÍPAD případ Z instrukce KONEC případ Z instrukce KONEC výchozí pokyny ENDCASE`	`stav LI valueIfTrue JINÝ valueIfFalse PAK`
OCaml	`-li stav pak začít instrukce konec «jinak začít instrukce konec»`	`-li stav pak začít instrukce skončit jinak, pokud stav pak začít instrukce konec ... «jinak začít instrukce konec»`	`zápas hodnota s vzor1 -> výraz \| vzor2 -> výraz ... «\| _ -> výraz"^[b]`	`-li stav pak valueIfTrue jiný valueIfFalse`
F#	Lehký režim syntaxe: Na jednom řádku nebo s odsazením, jak je uvedeno níže: `-li stav pak Záložka ↹ instrukce «jiný Záložka ↹ instrukce"` Režim podrobné syntaxe: Stejné jako standardní ML (níže).	Lehký režim syntaxe: Na jednom řádku nebo s odsazením, jak je uvedeno níže: `-li stav pak Záložka ↹ instrukce elif stav pak Záložka ↹ instrukce ... «jiný Záložka ↹ instrukce"` Režim podrobné syntaxe: Stejné jako standardní ML (níže).
Standardní ML	`-li stav pak «(»Pokyny«)» jiný «(»Pokyny«)»`	`-li stav pak «(»Pokyny«)» jinak pokud stav pak «(»Pokyny«)» ... jiný «(»Pokyny«)»`	`případ hodnota zvzor1 => výraz \| vzor2 => výraz ... «\| _ => výraz"^[b]`
Haskell (GHC)	`-li stav pak výraz jiný výraz` nebo `když stav (dělat instrukce)` nebo `ledaže podmínka (dělat instrukce)`	`výsledek \| stav = výraz \| stav = výraz \| jinak = výraz`	`případ hodnota z {vzor1 -> výraz; vzor2 ->výraz; ... «_ -> výraz" }^[b]`
Bash shell	`-li podmínka-příkaz; pak výraz «jiný výraz" fi`	`-li podmínka-příkaz; pak výraz elif podmínka-příkaz; pak výraz «jiný výraz" fi`	`případ „$ variable“ v „$ podmínka1“) příkaz... „$ podmínka2“) příkaz... esac`
CoffeeScript	`-li stav pak výraz «jiný výraz"`	`-li stav pak výraz jinak pokud stav pak výraz «jiný výraz"`	`přepínač výraz když stav pak výraz jiný výraz`	Všechny podmínky jsou výrazy
	`-li stav výraz «jiný výraz"`	`-li stav výraz jinak pokud stav výraz «jiný výraz"`	`přepínač výraz když stav pak výraz jiný výraz`
	`výraz -li stav`	`ledaže stav výraz jinak pokud stav výraz «jiný výraz"`	`přepínač výraz když stav výraz «jiný výraz"`
	`ledaže stav výraz «jiný výraz"`
	`výraz ledaže stav`
COBOL	`LI stav «PAK» výraz «JINÝ výraz".`^[d]		`HODNOCENÍ výraz «TAKY výraz..." KDYŽ případ nebo podmínka «TAKY případ nebo podmínka ... » výraz ... «KDY JINÉ výraz" KONEC HODNOCENÍ`
	-li	jinak pokud	vyberte případ	podmíněný výraz

^ a Na stejný řádek za dvojtečkou lze napsat jednu instrukci. Více pokynů je seskupeno do a blok který začíná na novém řádku (Je požadováno odsazení). Syntaxe podmíněného výrazu toto pravidlo nedodržuje.
^ b Tohle je porovnávání vzorů a je podobný vybranému případu, ale ne stejný. Obvykle se používá k dekonstrukci algebraické datové typy.
^ c V jazycích rodiny Pascalů není středník součástí prohlášení. Je to oddělovač mezi příkazy, nikoli terminátor.
^ d END-IF lze použít místo období na konci.

Smyčkové příkazy

	zatímco	dělat, zatímco	pro i = první až poslední	pro každého
Ada^[1]	`zatímco stav smyčka prohlášení koncová smyčka`	`smyčka prohlášení odejít, když ne stav koncová smyčka`	`pro index v «zvrátit" [za prvé .. poslední \| diskrétní_typ] smyčka prohlášení koncová smyčka`	`pro položka z «zvrátit»Iterátor smyčka prohlášení koncová smyčka (pro [Všechno \| nějaký] [v \| z] [za prvé .. poslední \| diskrétní_typ \| iterátor] => predikát)^[b]`
ALGOL 68	`«pro index »«z za prvé" "podle přírůstek »«na poslední »«zatímco stav" dělat prohlášení od`			`pro klíč «na upb seznam» dělat «typename val=seznam[klíč]; » prohlášení od`
ALGOL 68	`«zatímco stav"` dělat prohlášení od	`«zatímco prohlášení; stav"` dělat prohlášení od	`«pro index »«z za prvé" "podle přírůstek »«na poslední" dělat prohlášení od`
APL	`:Zatímco stavprohlášení : Konec`	`:Opakovat prohlášení :Dokud stav`	`:Pro var «s» :V seznamprohlášení : EndFor`	`:Pro var «s» :V každém seznamprohlášení : EndFor`
C (C99)	`instrukce` může to být jediný příkaz nebo blok ve formě: `{ prohlášení }` `zatímco (stav) instrukce`	`dělat instrukce zatímco (stav);`	`pro («Typ» i = za prvé; i <= poslední; i++) instrukce`	N / A
Cíl-C				`pro (zadejte položku v soubor) instrukce`
C ++ (STL)				`«std ::»pro každého(Start, konec, funkce)` (C ++ 11 ) `pro (zadejte položku : soubor) instrukce`
C#				`pro každého (zadejte položku v soubor) instrukce`
Jáva				`pro (zadejte položku : soubor) instrukce`
JavaScript			`pro (var i = za prvé; i <= poslední; i++) instrukce`	`pro (var položka z soubor) instrukce` (od té doby EcmaScript 2015^[11])
PHP			`foreach (rozsah (za prvé, poslední) jako $ i) pokyny nebo pro ($ i = za prvé; $ i <= poslední; $ i ++) instrukce`	`pro každého (soubor tak jako položka) instrukce nebo pro každého (soubor tak jako klíč => položka) instrukce`
Windows PowerShell			`pro ($ i = za prvé; $ i -le poslední; $ i ++) instrukce`	`pro každého (položka v soubor) pokyny pomocí položky`
D			`pro každého (i; za prvé ... poslední) pokyny`	`pro každého Pokyny (položka „typ“; sada)`
Jít	`pro stav { instrukce }`		`pro i := za prvé; i <= poslední; i++ { instrukce }`	`pro klíč, položka : = rozsah soubor { instrukce }`
Rychlý	`zatímco stav { instrukce }`	`opakovat { instrukce } zatímco stav` (2.x) `dělat { instrukce } zatímco stav` (1.x)	`pro i = za prvé ... poslední { instrukce }` nebo `pro i = za prvé ..< poslední + 1 { instrukce }` nebo `pro var i = za prvé; i <= poslední; i++ { instrukce }`	`pro položka v soubor { instrukce }`
Perl	`zatímco (stav) { instrukce } nebo dokud (podmínka) { instrukce }`	`dělat { instrukce } zatímco (stav) nebo dělat { instrukce } dokud (podmínka)`	`pro«každý»«$ i» (za prvé .. poslední) { instrukce } nebo pro ($ i = za prvé; $ i <= poslední; $ i ++) { instrukce }`	`pro«každý»« $ Položka » (soubor) { instrukce }`
Raku	`zatímco stav { instrukce } nebo dokud podmínka { instrukce }`	`opakovat { instrukce } zatímco stav nebo opakovat { instrukce } dokud podmínka`	`pro za prvé..poslední -> $ i { instrukce } nebo smyčka ($ i = za prvé; $ i <=poslední; $ i ++) { instrukce }`	`pro soubor"-> $ položka » { instrukce }`
Rubín	`zatímco stav instrukce konec nebo dokud podmínka instrukce konec`	`začít instrukce skončit chvíli stav nebo začít instrukce konec do podmínka`	`pro i dovnitř za prvé..poslední instrukce konec` nebo `pro i dovnitř za prvé...poslední + 1 instrukce konec nebo za prvé.až do(poslední) {\| i \| instrukce }`	`pro položka v soubor instrukce konec nebo soubor.each {\|položka\| instrukce }`
Bash shell	`zatímco stav;dělatinstrukce Hotovo nebo dokud podmínka;dělatinstrukce Hotovo`	N / A	`pro ((i = za prvé; i <= poslední; ++i)); dělatinstrukce Hotovo`	`pro položka v sada;dělatinstrukce Hotovo`
Scala	`zatímco (stav) { instrukce }`	`dělat { instrukce } zatímco (stav)`	`pro (i <- za prvé na poslední «o 1») { instrukce } nebo za prvé na poslední «o 1» pro každého (i => { instrukce })`	`pro (položka <- soubor) { instrukce } nebo soubor pro každého (položka => { instrukce })`
Pokec	`conditionBlock whileTrue: loopBlock`	`loopBlock dělat, zatímco: conditionBlock`	`za prvé na: poslední dělat: loopBlock`	`sbírka dělat: loopBlock`
Společný Lisp	`(smyčkazatímco stav dělat instrukce) nebo (do () (podmínka)instrukce)`	`(smyčkadělat instrukce zatímco stav)`	`(smyčkapro i od za prvé na poslední «od 1» dělat instrukce) nebo (tečky (i N)instrukce) nebo (dělat ((i za prvé (1+ i))) ((> = i poslední))instrukce)`	`(smyčkapro položka v seznam dělat instrukce) nebo (smyčkapro položka přes vektor dělat instrukce) nebo (dolist (seznam položek)instrukce) nebo (mapc seznam funkcí) nebo (mapa 'posloupnost funkcí)`
Systém	`(do () (podmínka) instrukce) nebo (let loop () (pokud stav (začít instrukce (smyčka))))`	`(nechat smyčku () (instrukce (li stav (smyčka))))`	`(dělat ((i za prvé (+ i 1))) ((> = i poslední)) instrukce) nebo (nechat smyčku ((i za prvé)) (pokud (poslední) (začít.) instrukce (smyčka (+ i 1)))))`	`(pro každého (lambda (položka) instrukce) seznam)`
ISLISP	`(zatímco stavinstrukce)`	`(smyčka tagbody instrukce (li stav (go loop))`	`(Protože já za prvé (+ i 1))) ((> = i poslední)) instrukce)`	`(mapc (lambda (položka) instrukce) seznam)`
Pascal	`zatímco stav začít instrukce konec`	`opakovat instrukce dokud podmínka;`	`pro i := za prvé "krok 1» na poslední začít instrukce konec;^[A]`	`pro položka v soubor dělat ...`
Visual Basic	`Dělat, zatímco stav instrukce Smyčka nebo Dělat do podmínka instrukce Smyčkanebo` `Zatímco podmínka` `instrukce` `Zamířit` (Visual Basic) `Konec` (Visual Basic .NET)	`Dělat instrukce Loop While stav nebo Dělat instrukce Smyčka do podmínka`	`i` musí být předem deklarováno.`Pro i = za prvé Na poslední"Krok 1»` `instrukce` `Příště já`	`Pro každého položka v soubor instrukce další položka`
Visual Basic .NET			`Protože já« Tak jako typ" = za prvé Na poslední"Krok 1» instrukce další« i»^[A]`	`Pro každého položka"Tak jako typ" v soubor instrukce další«Položka»`
Xojo	`Zatímco stav instrukce Zamířit`	`Dělat do podmínka instrukce Smyčka nebo Dělat instrukce Smyčka do podmínka`
Krajta	`zatímco stav : Záložka ↹ instrukce «jiný: Záložka ↹ instrukce"`	N / A	`pro i v dosahu (za prvé, poslední + 1): Záložka ↹ instrukce «jiný: Záložka ↹ instrukce"`(Python 3.x) `pro i v xrange (za prvé, poslední + 1): Záložka ↹ instrukce «jiný: Záložka ↹instrukce"`(Python 2.x)	`pro položka v soubor: Záložka ↹ instrukce «jiný: Záložka ↹ instrukce"`
Slang	`zatímco (stav) { instrukce } «pak volitelný blok »`	`dělat { instrukce } zatímco (stav) «pak volitelný blok »`	`pro (i = za prvé; i <= poslední; i ++) { instrukce } «pak volitelný blok »`	`pro každého položka(soubor) «použitím (co)» { instrukce } «pak volitelný blok »`
Fortran	`DĚLAT, ZATÍMCO (stav) instrukce KONEC`	`DĚLAT instrukce IF (stav) KONEC KONEC`	`DĚLAT Já = za prvé,poslední instrukce KONEC`	N / A
Forth	`ZAČÍT Podmínka «pokyny» ZATÍMCO instrukce OPAKOVAT`	`ZAČÍT podmínka instrukce DOKUD`	`limit start DĚLAT instrukce SMYČKA`	N / A
OCaml	`zatímco stav dělat instrukce Hotovo`	N / A	`pro i = za prvé na poslední dělat instrukce Hotovo`	`Array.iter (zábava položka -> instrukce) pole List.iter (zábava položka -> instrukce) seznam`
F#	`zatímco stav dělat Záložka ↹ instrukce`	N / A	`pro i = za prvé na poslední dělat Záložka ↹ instrukce`	`pro položka v soubor dělat Záložka ↹ instrukce nebo Seq.iter (zábava položka -> instrukce) soubor`
Standardní ML	`zatímco stav dělat ( instrukce )`	N / A		`Array.app (fn položka => instrukce) pole aplikace (fn položka => instrukce) seznam`
Haskell (GHC)	N / A		`Control.Monad.forM_ [za prvé..poslední] ( i -> dělat instrukce)`	`Control.Monad.forM_ seznam ( item -> dělat instrukce)`
Eiffelova	`z založit dokud stav smyčka instrukce konec`
CoffeeScript	`zatímco stav výraz`	N / A	`pro i v [první poslední] výraz`	`pro položka v soubor výraz`
	`výraz zatímco stav`
	`zatímco stav pak výraz`
	`dokud stav výraz`
	`výraz dokud stav`		`pro i v [první poslední] pak výraz`	`pro položka v soubor pak výraz`
	`dokud stav pak výraz`		`výraz pro i v [první poslední]`	`výraz pro položka v soubor`
COBOL	`PROVÉST postup-1 «PŘES postup-2 »« «S» TEST PŘED» DOKUD stav^[C]`	`PROVÉST postup-1 «PŘES postup-2 »«S» ZKOUŠKA PO DOBĚ stav^[C]`	`PROVÉST postup-1 «PŘES postup-2 » RŮZNÉ i Z za prvé PODLE přírůstek DOKUD i > poslední^[d]`	N / A
COBOL	`PROVÉST ««S» TEST PŘED» DOKUD stav výraz KONEC VÝKONU`	`PROVÉST «S» ZKOUŠKA PO DOBĚ stav výraz KONEC VÝKONU`	`VYMĚNIT VÝKON i Z za prvé PODLE přírůstek DOKUD i > poslední výraz KONEC VÝKONU^[d]`	N / A

^ a "krok n "se používá ke změně intervalu smyčky. Pokud"krok"je vynechán, pak je interval smyčky 1.

^ b Tím se implementuje univerzální kvantifikátor („pro všechny“ nebo „∀“) a také existenční kvantifikátor („existuje“ nebo „∃“).

^ c THRU lze použít místo PŘES.

^ d «JE» VĚTŠÍ «NEŽ» lze použít místo >.

Výjimky

	házet	psovod	tvrzení
Ada^[1]	`vyzdvihnout název_výjimky «s řetězec_výraz »`	`začítprohlášení výjimkakdyž seznam_výjimek₁ => prohlášení; když seznam_výjimek₂ => prohlášení; ... «když ostatní => prohlášení; » konec^[b]`	`pragma Assert («Zkontrolovat =>»Boolean_expression« «Zpráva =>»Řetězec_výraz») [funkce \| postup \| vstup] sPre => boolean_expression Příspěvek => boolean_expression jakýkoliv typ s Type_Invariant => boolean_expression`
APL	`«Řetězec_výraz» ⎕SIGNÁL number_expression`	`:Past číslo «s» _výrazprohlášení «:Případ číslo «s» _výrazprohlášení » ... «:Jiný číslo «s» _výrazprohlášení » : EndTrap`	`«Řetězec_výraz» ⎕SIGNÁL 98 / ⍨ ~stav`
C (C99)	`longjmp (Stát, výjimka);`	`přepínač (setjmp (Stát)) {případ 0: instrukce přestávka; případ výjimka: instrukce ... }`	`tvrdit (stav);`
C ++	`házet výjimka;`	`Snaž se { instrukce } chytit «(výjimka)» { instrukce } ...`	`tvrdit (stav);`
C#		`Snaž se { instrukce } chytit «(výjimka «jméno»)» { instrukce } ... «Konečně { instrukce }»`	`System.Diagnostics.Debug.Assert (stav);`nebo `System.Diagnostics.Trace.Assert (stav);`
Jáva		`Snaž se { instrukce } chytit (výjimka) { instrukce } ... «Konečně { instrukce }»`	`tvrdit stav «: popis»;`
JavaScript		`Snaž se { instrukce } chytit (výjimka) { instrukce } «Konečně { instrukce }»`	?
D		`Snaž se { instrukce } chytit (výjimka) { instrukce } ... «Konečně { instrukce }»`	`tvrdit (stav);`
PHP		`Snaž se { instrukce } chytit (výjimka) { instrukce } ... «Konečně { instrukce }»`	`tvrdit (stav);`
Slang		`Snaž se { instrukce } chytit "výjimka" { instrukce } ... «Konečně { instrukce }»`	?
Windows PowerShell		`past «[výjimka]» { instrukce } ... pokyny nebo Snaž se { instrukce } chytit «[výjimka]» { instrukce } ... «Konečně { instrukce }»`	`[Debug] :: Assert (stav)`
Cíl-C	`@házet výjimka;`	`@Snaž se { instrukce } @chytit (výjimka) { instrukce } ... «@Konečně { instrukce }»`	`NSAssert (stav, popis);`
Rychlý	`házet výjimka` (2.x)	`udělej to výraz ... instrukce } chytit výjimka { instrukce } ...` (2.x)	`tvrdit (stav«, popis»)`
Perl	`zemřít výjimka;`	`eval { instrukce }; pokud ($ @) { instrukce }`	?
Raku	`zemřít výjimka;`	`Snaž se { instrukce CATCH {kdy výjimka { instrukce } ...}}`	?
Rubín	`vyzdvihnout výjimka`	`začít instrukce zachránit výjimka instrukce ... «jiný instrukce" «zajistit instrukce" konec`
Pokec	`výjimka vyzdvihnout`	`instrukční blok na: výjimka dělat: handlerBlock`	`tvrdit: conditionBlock`
Společný Lisp	`(chyba "výjimka") nebo (chyba typ argumenty) nebo (chyba (podmínkatyp argumenty))`	`(psovod případ(progn instrukce) (pokyny k výjimce) ...) nebo (handler-bind(stav (lambda instrukce «vyvolat-restartovat restartovat args »)) ...)^[A]`	`(tvrdit stav) nebo (tvrdit stav«(místo) "chyba"") nebo (kontrolní typ var typ)`
Schéma (R.⁶RS)	`(vyzdvihnout výjimka)`	`(stráž (con (stavinstrukce) ...) instrukce)`	?
ISLISP	`(chyba "error-string" objekty) nebo (stav signálu podmínka kontinuální)`	`(s obsluhouforma obsluhy * )`	?
Pascal	`vyzdvihnout Výjimka.Create ()`	`Snaž se Až na na E: výjimka začít instrukce konec; konec;`	?
Visual Basic	`Err CHYBOVÉ ČÍSLO`	`S novým Snaž se: Při chybě Pokračovat dále OneInstruction .Chytit: On Error GoTo 0: Select Case .Číslo Případ CHYBOVÉ ČÍSLO instrukce Konec Vybrat: Konec s` '* Vyzkoušejte třídu *Soukromé mstr Popis Tak jako TětivaSoukromé mlngNumber Tak jako DlouhoVeřejnost Sub Chytit()mstr Popis = Chybovat.PopismlngNumber = Chybovat.ČísloKonec SubVeřejnost Vlastnictví Dostat Číslo() Tak jako DlouhoČíslo = mlngNumberKonec VlastnictvíVeřejnost Vlastnictví Dostat Popis() Tak jako TětivaPopis = mstr PopisKonec Vlastnictví ^[12]	`Debug.Assert stav`
Visual Basic .NET	`Házet výjimka`nebo `Chyba chybový kód`	`Snaž se instrukce Chytit" název Tak jako výjimka""Když stav" instrukce ... «Konečně instrukce" Konec pokusu`	`System.Diagnostics.Debug.Assert (stav)`nebo `System.Diagnostics.Trace.Assert (stav)`
Xojo	`Vyzdvihnout výjimka`	`Snaž se instrukce Chytit "výjimka"instrukce ... «Konečně instrukce" Konec pokusu`	N / A
Krajta	`vyzdvihnout výjimka`	`Snaž se: Záložka ↹ instrukce až na "výjimka": Záložka ↹ instrukce ... «jiný: Záložka ↹ instrukce" «Konečně: Záložka ↹ instrukce"`	`tvrdit stav`
Fortran	N / A
Forth	`kód HÁZET`	`xt CHYTIT (kód nebo 0)`	N / A
OCaml	`vyzdvihnout výjimka`	`Snaž se výraz s vzor -> výraz ...`	`tvrdit stav`
F#	`vyzdvihnout výjimka`	`Snaž se výraz s vzor -> výraz ... nebo Snaž se výraz Konečně výraz`	`tvrdit stav`
Standardní ML	`vyzdvihnout výjimka «arg»`	`výraz Rukojeť vzor => výraz ...`
Haskell (GHC)	`házet výjimka nebo throwError výraz`	`chytit tryExpression catchExpression nebo catchError tryExpression catchExpression`	`tvrdit podmínkový výraz`
COBOL	`VYZDVIHNOUT «VÝJIMKA»Výjimka`	`POUŽITÍ «PO» VÝJIMKOVÝ PŘEDMĚT jméno třídy. nebo POUŽITÍ «PO» EO jméno třídy. nebo POUŽITÍ «PO» PODMÍNKY VÝJIMKY název-výjimky «SOUBOR název souboru". nebo POUŽITÍ «PO» ES název výjimky «SOUBOR název souboru".`	N / A

^ a Společný Lisp umožňuje with-simple-restart, případ restartu a restartovat-svázat definovat restarty pro použití s vyvolat-restartovat. Neošetřené podmínky mohou způsobit, že implementace před odvíjením zásobníku uživateli zobrazí nabídku restartů.

^ b Nezachycené výjimky se šíří do nejvnitřnějšího dynamicky obklopujícího provedení. Výjimky se nešíří mezi úkoly (pokud nejsou tyto úkoly aktuálně synchronizovány na schůzce).

Další výkazy řízení toku

	výstupní blok (přestávka)	pokračovat	označení	větev (jít do )	návratová hodnota z generátoru
Ada^[1]	`výstup «Loop_name» «když stav"`	N / A	`označení:`	`jít do označení`	N / A
ALGOL 68	`hodnota výstup;` ...	`dělat prohlášení; přeskočit výjezd; štítek: prohlášení od`	`označení:` ...	`jít do označení; ... jít do označení; ... označení; ...`	`výtěžek(hodnota)` (Zpětné volání )^[13]
APL	`:Odejít`	`:Pokračovat`	`označení:`	`→označení nebo :Jít do označení`	N / A
C (C99)	`přestávka;`	`pokračovat;`	`označení:`	`jít do označení;`	N / A
Cíl-C
C ++ (STL)
D
C#					`výnos výnos hodnota;`
Jáva	`přestávka "označení";`	`pokračovat "označení";`		N / A
JavaScript	`přestávka "označení";`	`pokračovat "označení";`		N / A	`výtěžek hodnota";"`
PHP	`přestávka «Úrovně»;`	`pokračovat «Úrovně»;`		`jít do označení;`	`výtěžek «Klíč =>» hodnota;`
Perl	`poslední "označení";`	`další "označení";`
Raku	`poslední "označení";`	`další "označení";`
Jít	`přestávka "označení"`	`pokračovat "označení"`		`jít do označení`
Rychlý	`přestávka "označení"`	`pokračovat "označení"`		N / A
Bash shell	`přestávka «Úrovně»`	`pokračovat «Úrovně»`	N / A	N / A	N / A
Společný Lisp	`(vrátit se) nebo (návrat z blok) nebo (úprava smyčky)`		`(tagbody štítek... štítek ...)`	`(jít štítek)`
Systém
ISLISP	`(návrat z blok)`		`(tagbody štítek... štítek ...)`	`(jít štítek)`
Pascal (ISO)	N / A		`označení:`^[A]	`jít do označení;`	N / A
Pascal (FPC)	`přestávka;`	`pokračovat;`	`označení:`^[A]	`jít do označení;`
Visual Basic	`Výstup blok`Alternativně pro metody `Vrátit se`	N / A	`označení:`	`Jít do označení`
Xojo		`Pokračovat blok`
Visual Basic .NET		`Pokračovat blok`			`Výtěžek hodnota`
Krajta	`přestávka`	`pokračovat`	N / A		`výtěžek hodnota`
RPG IV	`ODEJÍT;`	`ITER;`
Slang	`přestávka;`	`pokračovat;`
Fortran	`VÝSTUP`	`CYKLUS`	`označení`^[b]	`JÍT DO označení`	N / A
Rubín	`přestávka`	`další`
Windows PowerShell	`přestávka "označení"`	`pokračovat`
OCaml	N / A
F#
Standardní ML
Haskell (GHC)
COBOL	`KONEC VÝKONU nebo VÝSTUPNÍ ODSTAVEC nebo VÝSTUPNÍ SEKCE nebo VÝSTUP.`	`UKONČTE VÝKONNÝ CYKLUS`	`štítek «SEKCE».`	`JÍT DO označení`	N / A
Ya	`přestávka "odkud";` např. `přestávka na vypínač;`	`pokračovat "kam";` např. `pokračovat pro přepnutí;`	`:označení`	`jít do :označení;`	N / A

^ a Pascal má deklarační bloky. Vidět Porovnání programovacích jazyků (základní pokyny) #Functions.
^ b štítek musí být číslo mezi 1 a 99999.

Funkce

Vidět odraz pro volání a deklaraci funkcí pomocí řetězců.

	volání funkce	základní / neplatná funkce	funkce návratu hodnoty	Požadované hlavní funkce
Ada^[1]	`foo «(Parametry)»`	`postup foo «(Parametry)» je začátek prohlášení konec foo`	`funkce foo «(Parametry)» vrátit se typ je začátek prohlášení konec foo`	N / A
ALGOL 68	`foo«(Parametry)»;`	`proc foo = «(Parametry)» prázdnota: ( instrukce );`	`proc foo = «(Parametry)» rettype: ( pokyny ...; retalue );`	N / A
APL	`«Parametry» foo parametry`	`foo←{ prohlášení }`	`foo←{ prohlášení }`	N / A
C (C99)	`foo («Parametry»)`	`prázdnota foo («Parametry») { instrukce }`	`typ foo («Parametry») { pokyny ... vrátit se hodnota; }`	`«Globální prohlášení» int hlavní («int argc, char * argv []») { instrukce }`
Cíl-C
C ++ (STL)
Jáva				`public static void main (String [] args) { instrukce } nebo public static void main (Řetězec... args) { instrukce }`
D				`int hlavní («char [] [] args») { instrukce} nebo int hlavní («řetězec [] args») { instrukce} nebo void main («char [] [] args») { instrukce} nebo void main («řetězec [] args») { instrukce}`
C#		Stejné jako výše; alternativně, pokud pouze jedno prohlášení: `prázdnota foo («Parametry») => prohlášení;`	Stejné jako výše; alternativně, pokud je to dost jednoduché na to, aby to byl výraz: `prázdnota foo («Parametry») => výraz;`	`static void Main («řetězec [] args») method_body` Může se místo toho vrátit `int`. (počínaje C # 7.1 :) Může se vrátit `Úkol` nebo `Úkol` , a pokud ano, může být `asynchronní`.
JavaScript		`funkce foo («Parametry») { instrukce } nebo var foo = funkce («Parametry») {instrukce } nebo var foo = nová funkce («"parametr", ... ,"poslední parametr"» "instrukce");`	`funkce foo («Parametry») { pokyny ... vrátit se hodnota; }`	N / A
Jít		`func foo («Parametry») { instrukce }`	`func foo («Parametry») typ { pokyny ... vrátit se hodnota }`	`func main () { instrukce }`
Rychlý		`func foo («Parametry») { instrukce }`	`func foo («Parametry») -> typ { pokyny ... vrátit se hodnota }`	N / A
Společný Lisp	`(foo «Parametry»)`	`(defun foo («Parametry»)instrukce) nebo (setf (symbol-funkce 'symbol)funkce)`	`(defun foo («Parametry»)... hodnota)`	N / A
Systém		`(definovat (foo parametry) instrukce) nebo (definovat foo (lambda (parametry) instrukce))`	`(definovat (foo parametry) pokyny ... návratová_hodnota) nebo (definovat foo (lambda (parametry) pokyny ... návratová_hodnota))`
ISLISP		`(defun foo («Parametry»)instrukce)`	`(defun foo («Parametry»)... hodnota)`
Pascal	`foo«(parametry)»`	`postup foo«(parametry)»; «vpřed;»^[A] «označenídeklarace štítků » «konstkonstantní deklarace » «typtypová prohlášení » «vardeklarace proměnných » «Místní deklarace funkcí» začítinstrukce konec;`	`funkce foo«(parametry)»: typ; «vpřed;»^[A] «označenídeklarace štítků » «konstkonstantní deklarace » «typtypová prohlášení » «vardeklarace proměnných » «Místní deklarace funkcí» začít instrukce; foo: = hodnota konec;`	`program název; «označenídeklarace štítků » «konstkonstantní deklarace » «typtypová prohlášení » «vardeklarace proměnných » «Deklarace funkcí» začítinstrukce konec.`
Visual Basic	`Foo («Parametry»)`	`Sub Foo«(parametry)» instrukce End Sub`	`Funkce Foo«(parametry)»« Tak jako typ"instrukce Foo = hodnota Ukončit funkci`	`Sub Main ()instrukce End Sub`
Visual Basic .NET			Stejné jako výše; alternativně:`Funkce Foo«(parametry)»« Tak jako typ"` `instrukce Vrátit se hodnota` `Ukončit funkci` The `Tak jako` klauzule se nevyžaduje, pokud `Možnost přísná` je vypnutý. Místo znaku lze použít znak typu `Tak jako` doložka. Pokud ovládací prvek ukončí funkci bez výslovně zadané návratové hodnoty, vrátí funkce výchozí hodnotu pro návratový typ.	`Sub Main (««ByVal »args () Jako řetězec») instrukce End Sub`nebo`Funkce Hlavní (««ByVal »args () Jako řetězec») Jako celé číslo` `instrukce` `Ukončit funkci`
Xojo
Krajta	`foo («Parametry»)`	`def foo («Parametry»): Záložka ↹ instrukce`	`def foo («Parametry»): Záložka ↹ instrukce Záložka ↹ vrátit se hodnota`	N / A
Slang	`foo («Parametry» «; kvalifikace»)`	`definovat foo («Parametry») { instrukce }`	`definovat foo («Parametry») { pokyny ... vrátit se hodnota; }`	`public define slsh_main () { instrukce }`
Fortran	`foo («Argumenty») VOLEJTE sub_foo («Argumenty»)^[C]`	`SUBROUTINE sub_foo («Argumenty») instrukce KONEC PODPROGRAMU^[C]`	`typ FUNKCE foo («Argumenty») instrukce ... foo = hodnota KONEC FUNKCE^[C]`	`PROGRAM hlavní instrukce KONEC PROGRAMU`
Forth	`«Parametry» FOO`	`: FOO « komentář k zásobníku: ( před -- ) » instrukce ;`	`: FOO « komentář k zásobníku: ( před -- po ) » instrukce ;`	N / A
PHP	`foo («Parametry»)`	`funkce foo («Parametry») { instrukce }`	`funkce foo («Parametry») { instrukce ... vrátit se hodnota; }`	N / A
Perl	`foo («Parametry») nebo & foo«(parametry)»`	`sub foo { «můj (parametry) = @_;»instrukce }`	`sub foo { «můj (parametry) = @_;»instrukce... «vrátit se»hodnota; }`
Raku	`foo («Parametry») nebo & foo«(parametry)»`	`«multi »sub foo (parametry) { instrukce }`	`«náš «Typ» »«multi »sub foo (parametry) { instrukce... «vrátit se»hodnota; }`
Rubín	`foo«(parametry)»`	`def foo«(parametry)» instrukce konec`	`def foo«(parametry)» instrukce «vrátit se»Hodnota konec`
Rez	`foo («Parametry»)`	`fn foo («Parametry») { instrukce }`	`fn foo («Parametry») -> typ { instrukce }`	`fn main () { instrukce }`
Scala	`foo«(parametry)»`	`def foo«(parametry)»«: Jednotka =» { instrukce }`	`def foo«(parametry)»«: typ" = { pokyny ... «vrátit se»Hodnota }`	`def main (args: Array [String]) { instrukce }`
Windows PowerShell	`foo «Parametry»`	`funkce foo { instrukce }; nebo funkce foo { «param (parametry)» instrukce }`	`funkce foo «(parametry)» { instrukce … vrátit se hodnota }; nebo funkce foo { «param (parametry)» instrukce … vrátit se hodnota }`	N / A
Bash shell	`foo «Parametry»`	`funkce foo { instrukce }`nebo`foo () { instrukce }`	`funkce foo { instrukce vrátit se «Exit_code» }`nebo`foo () { instrukce vrátit se «Exit_code» }`
Bash shell	`foo «Parametry»`	parametry `$n` ($1, $2, $3, ...) `$@` (všechny parametry) `$#` (počet parametrů) `$0` (tento název funkce)
OCaml	`foo parametry`	`nechat «rec» foo parametry = instrukce`	`nechat «rec» foo parametry = pokyny ... návratová_hodnota`
F#		`nechat «rec» foo parametry = instrukce`	`nechat «rec» foo parametry = pokyny ... návratová_hodnota`	`[] nechat hlavní args = instrukce`
Standardní ML		`zábava foo parametry = ( instrukce )`	`zábava foo parametry = ( pokyny ... návratová_hodnota )`
Haskell		`foo parametry = dělat Záložka ↹ instrukce`	`foo parametry = návratová_hodnota nebo foo parametry = dělat Záložka ↹ instrukce Záložka ↹ vrátit se hodnota`	`«main :: IO ()» main = dělat instrukce`
Eiffelova	`foo («Parametry»)`	`foo («Parametry») vyžadovat předpoklady dělat instrukce zajistit dodatečné podmínky konec`	`foo («Parametry»): typ vyžadovat předpoklady dělat instrukce Výsledek : = hodnota zajistit dodatečné podmínky konec`	^[b]
CoffeeScript	`foo ()`	`foo = ->`	`foo = -> hodnota`	N / A
CoffeeScript	`foo parametry`	`foo = () ->`	`foo = ( parametry ) -> hodnota`	N / A
COBOL	`VOLÁNÍ "foo" «POUŽITÍM parametry » «Zpracování výjimek» «UKONČIT HOVOR»`^[d]	`«IDENTIFIKAČNÍ DIVIZE.» ID PROGRAMU. foo. «Další divize ...» ROZDĚLENÍ POSTUPŮ «POUŽITÍM parametry ». instrukce.`	`«IDENTIFIKAČNÍ DIVIZE.» ID PROGRAMU/ID FUNKCE. foo. «Další divize ...» DIVIZE DAT. «Další sekce ...» SEKCE LINKAGE. «Definice parametrů ...» definice proměnné k návratu «Další sekce ...» ROZDĚLENÍ POSTUPŮ «POUŽITÍM parametry » VRÁCENÍ proměnná k návratu. instrukce.`	N / A
COBOL	`«FUNKCE»Foo« («parametry») »`	N / A		N / A

^ a Pascal vyžaduje „vpřed;" pro předat prohlášení.
^ b Eiffel umožňuje specifikaci kořenové třídy a funkce aplikace.
^ c Ve Fortranu se parametry funkce / podprogramu nazývají argumenty (od PARAMETR je klíčové slovo jazyka); the VOLÁNÍ klíčové slovo je vyžadováno pro podprogramy.
^ d Místo použití "foo", místo toho může být použita řetězcová proměnná obsahující stejnou hodnotu.

Zadejte převody

Kde tětiva je podepsané desetinné číslo:

	řetězec na celé číslo	řetězec na dlouhé celé číslo	řetězec na plovoucí desetinnou čárku	celé číslo do řetězce	plovoucí desetinná čárka na řetězec
Ada^[1]	`Integer'Value (řetězec_výraz)`	`Long_Integer'Value (řetězec_výraz)`	`Float'Value (řetězec_výraz)`	`Integer'Image (integer_expression)`	`Float'Image (float_expression)`
ALGOL 68 s obecnými a poté specifickými formáty	S předchozími prohlášeními a sdružením: `tětiva buf: = "12345678.9012e34"; soubor zástupce; spolupracovník (proxy, buf);`
	get (proxy, ivar);	get (proxy, livar);	get (proxy, rvar);	put (proxy, ival);	put (proxy, rval);
	getf (proxy, ($ g $, ivar)); nebo getf (proxy, ($ dddd $, ivar));	getf (proxy, ($ g $, livar)); nebo getf (proxy, ($ 8d $, livar));	getf (proxy, ($ g $, rvar)); nebo getf (proxy, ($ 8d.4dE2d $, rvar));	putf (proxy, ($ g $, ival)); nebo putf (proxy, ($ 4d $, ival));	putf (proxy, ($ g (šířka, místa, exp) $, rval)); nebo putf (proxy, ($ 8d.4dE2d $, rval));
APL	`⍎řetězec_výraz`	`⍎řetězec_výraz`	`⍎řetězec_výraz`	`⍕integer_expression`	`⍕float_expression`
C (C99)	`celé číslo = atoi (tětiva);`	`dlouho = atol (tětiva);`	`plovák = atof (tětiva);`	`sprintf (tětiva, "% i", celé číslo);`	`sprintf (tětiva, "% f", plovák);`
Cíl-C	`celé číslo = [tětiva intValue];`	`dlouho = [tětiva longLongValue];`	`plovák = [tětiva doubleValue];`	`tětiva = [NSString stringWithFormat: @ "% i", celé číslo];`	`tětiva = [NSString stringWithFormat:@"%F", plovák];`
C ++ (STL)	`«std ::»istringstream (tětiva) >> číslo;`			`«std ::»ostringstream Ó; Ó << číslo; tětiva = Ó.str ();`
C ++ 11	`celé číslo = «std ::»Stoi (tětiva);`	`dlouho = «std ::»Stol (tětiva);`	`plovák = «std ::»Stof (tětiva); dvojnásobek = «std ::»Stod (tětiva);`	`tětiva = «std ::»To_string (číslo);`
C#	`celé číslo = int. parse(tětiva);`	`dlouho = dlouhá(tětiva);`	`plovák = float.parse(tětiva);` `dvojnásobek = zdvojnásobit(tětiva);`	`tětiva = číslo.ToString ();`
D	`celé číslo = std.conv.to! int(tětiva)`	`dlouho = std.conv.to! long(tětiva)`	`plovák = std.conv.to! float(tětiva)` `dvojnásobek = std.conv.to! double(tětiva)`	`tětiva = std.conv.to! řetězec(číslo)`
Jáva	`celé číslo = Integer.parseInt(tětiva);`	`dlouho = Long.parseLong(tětiva);`	`plovák = Float.parseFloat(tětiva); dvojnásobek = Double.parseDouble(tětiva);`	`tětiva = Integer.toString(celé číslo);` `tětiva = String.valueOf(celé číslo);`	`tětiva = Float.toString(plovák);` `tětiva = Double.toString(dvojnásobek);`
JavaScript^[A]	`celé číslo = parseInt (tětiva);`		`plovák = parseFloat (tětiva);` `plovák = nové číslo (tětiva);` `plovák = Číslo (tětiva);` `plovák = +tětiva;`	tětiva = číslo.toString (); tětiva = Řetězec (číslo); tětiva = číslo+""; tětiva = `${číslo}`
Jít	`celé číslo, chyba = strconv.Atoi (tětiva) celé číslo, chyba = strconv.ParseInt(tětiva, 10, 0)`	`dlouho, chyba = strconv.ParseInt(tětiva, 10, 64)`	`plovák, chyba = strconv.ParseFloat(tětiva, 64)`	`tětiva = strconv.Itoa (celé číslo)` `tětiva = strconv.FormatInt(celé číslo, 10)` `tětiva = fmt. tisk (celé číslo)`	`tětiva = strconv.FormatFloat(plovák)` `tětiva = fmt. tisk(plovák)`
Rez^[d]	`tětiva.parse :: ()` `i32 :: from_str (tětiva)`	`tětiva.parse :: ()` `i64 :: from_str (tětiva)`	`tětiva.parse :: ()` `f64 :: from_str (tětiva)`	`celé číslo.to_string ()`	`plovák.to_string ()`
Společný Lisp	`(setf celé číslo (analyzovat celé číslo tětiva))`		`(setf plovák (čtení z řetězce tětiva))`	`(setf tětiva (tisk-na-řetězec číslo))`
Systém	`(definovat číslo (řetězec-> číslo tětiva))`			`(definovat tětiva (číslo-> řetězec číslo))`
ISLISP	`(setf celé číslo (konvertovat tětiva ))`		`(setf plovák (konvertovat tětiva ))`	`(setf tětiva (konvertovat číslo <řetězec>))`
Pascal	`celé číslo : = StrToInt (tětiva);`		`plovák : = StrToFloat (tětiva);`	`tětiva : = IntToStr (celé číslo);`	`tětiva : = FloatToStr (plovák);`
Visual Basic	`celé číslo = CInt (tětiva)`	`dlouho = CLng (tětiva)`	`plovák = CSng (tětiva) dvojnásobek = CDbl (tětiva)`	`tětiva = CStr (číslo)`
Visual Basic .NET (lze použít obě syntaxe VB výše a metody .NET zobrazené vpravo)	`celé číslo = Celé číslo(tětiva)`	`dlouho = Long.parse(tětiva)`	`plovák = Single.parse(tětiva)` `dvojnásobek = Double.Parse(tětiva)`	`tětiva = číslo.ToString ()`
Xojo	`celé číslo = Val (tětiva)`	`dlouho = Val (tětiva)`	`dvojnásobek = Val (tětiva)` `dvojnásobek = CDbl (tětiva)`	`tětiva = CStr (číslo) nebo` `tětiva = Str (číslo)`
Krajta	`celé číslo = int (tětiva)`	`dlouho = dlouhý (tětiva)`	`plovák = float (tětiva)`	`tětiva = str (číslo)`
Slang	`celé číslo = atoi (tětiva);`	`dlouho = atol (tětiva);`	`plovák = atof (tětiva);`	`tětiva = řetězec (číslo);`
Fortran	`ČÍST(tětiva,formát) číslo`			`PSÁT SI(tětiva,formát) číslo`
PHP	`celé číslo = intval (tětiva); nebo` `celé číslo = (int)tětiva;`		`plovák = floatval (tětiva);` `plovák = (float)tětiva;`	`tětiva = "$ číslo"; nebo` `tětiva = strval (číslo); nebo` `tětiva = (řetězec)číslo;`
Perl^[b]	`číslo = 0 + tětiva;`			`tětiva = "číslo";`
Raku	`číslo = +tětiva;`			`tětiva = ~číslo;`
Rubín	`celé číslo = tětiva.to_i nebo` `celé číslo = Celé číslo (tětiva)`		`plovák = tětiva.to_f` `plovák = Float (tětiva)`	`tětiva = číslo.to_s`
Scala	`celé číslo = tětiva.toInt`	`dlouho = tětiva.dlouho`	`plovák = tětiva.toFloat` `dvojnásobek = tětiva.doDouble`	`tětiva = číslo.toString`
Pokec	`integer: = Integer readFrom: tětiva`		`float: = Float readFrom: tětiva`	`řetězec: = číslo jako řetězec`
Windows PowerShell	`celé číslo = [int]tětiva`	`dlouho = [dlouhý]tětiva`	`plovák = [float]tětiva`	`tětiva = [řetězec]číslo; nebo tětiva = "číslo"; nebo tětiva = (číslo). ToString ()`
OCaml	`nechat celé číslo = int_of_string tětiva`		`nechat plovák = float_of_string tětiva`	`nechat tětiva = řetězec_of_int celé číslo`	`nechat tětiva = řetězec_of_float plovák`
F#	`nechat celé číslo = int tětiva`	`nechat celé číslo = int64 tětiva`	`nechat plovák = float tětiva`	`nechat tětiva = řetězec číslo`
Standardní ML	`val celé číslo = Int.fromString tětiva`		`val plovák = Skutečné.fromString tětiva`	`val tětiva = Int.toString celé číslo`	`val tětiva = Skutečné.toString plovák`
Haskell (GHC)	`číslo = číst tětiva`			`tětiva = ukázat číslo`
COBOL	`HÝBAT SE «FUNKCE» NUMVAL (tětiva)^[C] NA číslo`			`HÝBAT SE číslo NA číselné úpravy`

^ a JavaScript používá pouze čísla s plovoucí desetinnou čárkou, takže existují určité technické aspekty.^[7]
^ b Perl nemá samostatné typy. Řetězce a čísla jsou zaměnitelné.
^ c NUMVAL-C nebo NUMVAL-F lze použít místo NUMVAL.
^ str :: parse je k dispozici pro převod jakéhokoli typu, který má implementaci std :: str :: FromStr vlastnost. Oba str :: parse a FromStr :: from_str vrátit a Výsledek který obsahuje zadaný typ, pokud nedojde k chybě. The turbofish (::<_>) zapnuto str :: parse lze vynechat, pokud lze typ odvodit z kontextu.

Standardní stream I / O

	číst z	napsat
	stdin	stdout	stderr
Ada^[1]	`Dostat (X)`	`Dát (X)`	`Put (Standard_Error, X)`
ALGOL 68	`readf (($ formát $, X)); nebo getf (postavit se, ($ formát $, X));`	`printf (($ formát $, X)); nebo putf (vyniknout, ($ formát $, X));`	`putf (chyba stojanu, ($ formát $, X));^[A]`
APL	`x ←⎕`	`⎕←X`	`⍞←X`
C (C99)	`scanf (formát, &X); nebo fscanf (stdin, formát, &X); ^[b]`	`printf ( formát, X); nebo fprintf (standardní výstup, formát, X); ^[C]`	`fprintf (stderr, formát, X );^[d]`
Cíl-C	`data = [[NSFileHandle fileHandleWithStandardInput] readDataToEndOfFile];`	`[[NSFileHandle fileHandleWithStandardOutput] writeData:data];`	`[[NSFileHandle fileHandleWithStandardError] writeData:data];`
C ++	`«std ::»cin >> X; nebo «std ::»getline («std ::»cin, str);`	`«std ::»cout << X;`	`«std ::»cerr << X; nebo «std ::»dřevák << X;`
C#	`X = Console.Read (); neboX = Console.ReadLine ();`	`Console.Write ("formát, "X); nebo Console.WriteLine ("formát, "X);`	`Chyba konzoly.Psát si("formát, "X); nebo Chyba konzoly.WriteLine ("formát, "X);`
D	`x = std.stdio.readln ()`	`std.stdio.write (X) nebo std.stdio.writeln (X) nebo std.stdio.writef (formát, X) nebo std.stdio.writefln (formát, X)`	`stderr.write (X) nebo stderr.writeln (X) nebo std. stdio.writef (stderr, formát, X) nebo std. stdio.writefln (stderr, formát, X)`
Jáva	`X = System.in.read (); nebo X = nový skener (System.in).nextInt (); nebo X = nový skener (System.in).nextLine ();`	`System.out.print (X); nebo System.out.printf (formát, X); nebo System.out.println (X);`	`System.err.print (X); nebo System.err.printf (formát, X); nebo System.err.println (X);`
Jít	`fmt.Scan (&X) nebo fmt.Scanf (formát, &X) nebo x = bufio.NewReader (os.Stdin).ReadString (' n')`	`fmt.Println (X) nebo fmt.Printf (formát, X)`	`fmt.Fprintln (os.Stderr, X) nebo fmt.Fprintf (os. Stderr, formát, X)`
Rychlý	`x = readLine ()` (2.x)	`tisk(X)` (2.x) `println (X)` (1.x)
JavaScript Implementace webového prohlížeče		`document.write (X)`
JavaScript Stránky aktivního serveru		`Response.Write (X)`
JavaScript Hostitel skriptů Windows	`X = WScript.StdIn.Read (znaky) nebo X = WScript.StdIn.ReadLine ()`	`WScript.Echo (X) nebo WScript.StdOut.Write (X) nebo WScript.StdOut.WriteLine (X)`	`WScript.StdErr.Write (X) nebo WScript.StdErr.WriteLine (X)`
Společný Lisp	`(setf X (řádek pro čtení))`	`(princ X) nebo (formát t formát x)`	`(princ X * chybový výstup ) nebo (formát chybový výstup * formát x)`
Schéma (R.⁶RS)	`(definovat X (řádek pro čtení))`	`(Zobrazit X) nebo (formát # t formát x)`	`(Zobrazit X (aktuální-chybový-port)) nebo (formát (aktuální-chybový-port) formát x)`
ISLISP	`(setf X (řádek pro čtení))`	`(formát (standardní výstup) formát x)`	`(formát (chybový výstup) formát x)`
Pascal	`číst(X); nebo číst (X);`	`psát si(X); nebo writeln (X);`	`napsat (stderr, X); nebo writeln (stderr, X);`
Visual Basic	`Vstup" výzva,»X`	`Tisk x nebo ? X`	N / A
Visual Basic .NET	`X = Console.Read () nebo X = Console.ReadLine ()`	`Console.Write ("formát, "X) nebo Console.WriteLine ("formát, "X)`	`Chyba konzoly.Psát si("formát, "X) nebo Chyba konzoly.WriteLine ("formát, "X)`
Xojo	`X = StandardInputStream.Read () nebo X = StandardInputStreame.ReadLine ()`	`StandardOutputStream.Write (X) nebo StandardOutputStream.WriteLine (X)`	`StdErr.Write (X) nebo StdErr.WriteLine (X)`
Python 2.x.	`X = raw_input ("výzva")`	`tisk x nebo sys.stdout.write (X)`	`tisk >> sys.stderr, x nebo sys.stderr.write (X)`
Python 3.x.	`X = vstup ("výzva")`	`tisk(X", end = ""»)`	`tisk(X", end = ""», file = sys.stderr)`
Slang	`fgets (&X, stdin)`	`fputs (X, standardní výstup)`	`fputs (X, stderr)`
Fortran	`ČÍST(*,formát) názvy proměnných nebo PŘEČTĚTE SI (INPUT_UNIT,formát) názvy proměnných^[E]`	`PSÁT SI(*,formát) výrazy nebo WRITE (OUTPUT_UNIT,formát) výrazy^[E]`	`WRITE (ERROR_UNIT,formát) výrazy^[E]`
Forth	`délka vyrovnávací paměti AKCEPTOVAT (přečteno # znaků) KLÍČ (char)`	`délka vyrovnávací paměti TYP char VYSÍLAT`	N / A
PHP	`$ x = fgets (STDIN); nebo $ x = fscanf (STDIN, formát);`	`tisk X; nebo echoX; nebo printf (formát, X);`	`fprintf (STDERR, formát, X);`
Perl	`$ x = <>; nebo $ x = ;`	`tisk X; nebo printfformát, X;`	`tisknout STDERR X; nebo printf STDERR formát, X;`
Raku	`$ x = $ * IN.get;`	`X.tisk nebo X.říci`	`X.Poznámka nebo $ * ERR.print (X) nebo $ * ERR.say (X)`
Rubín	`X = dostane`	`uvádí x nebo printf (formát, X)`	`$ stderr.puts (X) nebo $ stderr.printf (formát, X)`
Windows PowerShell	`$ x = Hostitel čtení«« -Výzva" text"; nebo $ x = [Konzole] :: Číst (); nebo $ x = [Konzole] :: ReadLine ()`	`X; nebo Zápis-výstup X; nebo echo X`	`Chyba zápisu X`
OCaml	`nechat X = read_int () nebo nechat str = read_line () nebo Scanf.scanf formát (zábava X ... -> ...)`	`print_int x nebo print_endline str nebo Printf.printf formát x ...`	`prerr_int x nebo prerr_endline str nebo Printf.eprintf formát x ...`
F#	`nechat X = System.Console.ReadLine ()`	`printf formát x ... nebo printfn formát x ...`	`eprintf formát x ... nebo eprintfn formát x ...`
Standardní ML	`val str = TextIO.inputLIne TextIO.stdIn`	`tisk str`	`TextIO.output (TextIO.stdErr, str)`
Haskell (GHC)	`X <- readLn nebo str <- getLine`	`tisk x nebo putStrLn str`	`hPrint stderr x nebo hPutStrLn stderr str`
COBOL	`AKCEPTOVAT X`	`ZOBRAZIT X`

^ a ALGOL 68 navíc jako „neformátovaný“ transput rutiny: číst, psát si, dostat a dát.
^ b dostane (X) a fgets (X, délka, stdin) číst neformátovaný text ze stdin. Použití get se nedoporučuje.
^ c uvádí (X) a fputs (x, standardní výstup) zapsat neformátovaný text do standardního výstupu.
^ d fputs (x, stderr) zapíše neformátovaný text do stderr
^ e INPUT_UNIT, OUTPUT_UNIT, ERROR_UNIT jsou definovány v ISO_FORTRAN_ENV modul.^[14]

Čtení argumenty příkazového řádku

	Hodnoty argumentů	Argument se počítá	Název programu / název skriptu
Ada^[1]	`Argument (n)`	`Argument_Count`	`Command_Name`
C (C99)	`argv [n]`	`argc`	první argument
Cíl-C
C ++
C#	`args [n]`	`délka oblouků`	`Assembly.GetEntryAssembly ().Umístění;`
Jáva		`délka oblouk`
D		`délka oblouk`	první argument
JavaScript Hostitel skriptů Windows implementace	`WScript.Arguments (n)`	`WScript.Arguments.length`	`WScript.ScriptName nebo WScript.ScriptFullName`
Jít	`os.Args [n]`	`len (os.Args)`	první argument
Rez^[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 ()`
Rychlý	`Process.arguments [n]` nebo `Process.unsafeArgv [n]`	`Process.arguments.count` nebo `Process.argc`	první argument
Společný Lisp	?	?	?
Schéma (R.⁶RS)	`(list-ref (příkazový řádek) n)`	`(délka (příkazový řádek))`	první argument
ISLISP	N / A	N / A	N / A
Pascal	`ParamStr (n)`	`ParamCount`	první argument
Visual Basic	`Příkaz`^[b]	N / A	`App.Path`
Visual Basic .NET	`CmdArgs (n)`	`CmdArgs.Length`	`[Assembly] .GetEntryAssembly (). Umístění`
Xojo	`System.CommandLine`	(analýza řetězce)	Application.ExecutableFile.Name
Krajta	`sys.argv [n]`	`len (sys.argv)`	první argument
Slang	`__argv [n]`	`__argc`	první argument
Fortran	`DĚLAT i = 1,argc VOLEJTE GET_COMMAND_ARGUMENT (i,argv (i)) KONEC`	`argc = COMMAND_ARGUMENT_COUNT ()`	`VOLEJTE GET_COMMAND_ARGUMENT (0,progname)`
PHP	`$ argv [n]`	`$ argc`	první argument
Bash shell	`$n ($1, $2, $3, ...)` `$@` (všechny argumenty)	`$#`	`$0`
Perl	`$ ARGV [n]`	`skalární (@ARGV)`	`$0`
Raku	`@ * ARGS [n]`	`@ * ARGS.elems`	`$ PROGRAM_NAME`
Rubín	`ARGV [n]`	`ARGV.size`	`$0`
Windows PowerShell	`$ args [n]`	`$ args. Délka`	`$ MyInvocation.MyCommand.Název`
OCaml	`Sys.argv. (n)`	`Array.length Sys.argv`	první argument
F#	`args. [n]`	`délka oblouků`	`Assembly.GetEntryAssembly ().Umístění`
Standardní ML	`List.nth (CommandLine.argumenty (), n)`	`délka (CommandLine.argumenty ())`	`CommandLine.name ()`
Haskell (GHC)	`dělat { args <- Systém.getArgs; vrátit se délka args !! n`}	`dělat { args <- Systém.getArgs; vrátit se délka args`}	`System.getProgName`
COBOL	^[C]		N / A

^ a V Rustu std :: env :: args a std :: env :: args_os vrátit iterátory, std :: env :: Args a std :: env :: ArgsOs resp. Args převede každý argument na a Tětiva a panikaří, pokud dosáhne argumentu, na který nelze převést UTF-8. ArgsOs vrací neztrátovou reprezentaci surových řetězců z operačního systému (std :: ffi :: OsString), což může být neplatný UTF-8.
^ b V jazyce Visual Basic nejsou argumenty příkazového řádku odděleny. Jejich oddělení vyžaduje funkci rozdělení Rozdělit(tětiva).
^ c Standard COBOL neobsahuje žádné prostředky pro přístup k argumentům příkazového řádku, ale běžná rozšíření kompilátoru pro přístup k nim zahrnují definování parametrů pro hlavní program nebo použití AKCEPTOVAT prohlášení.

Provádění příkazů

	Příkaz prostředí	Proveďte program	Nahraďte aktuální program novým spuštěným programem
Ada^[1]	Není součástí jazykového standardu. Běžně se provádí pomocí balíčků poskytovaných překladačem nebo propojením s C nebo POSIX.^[15]
C	`Systém ("příkaz");`		`kromě (cesta, args); nebo vykon (cesta, arglist);`
C ++			`kromě (cesta, args); nebo vykon (cesta, arglist);`
Cíl-C		`[NSTask launchTaskWithLaunchPath: (NSString )cesta argumenty: (NSArray )argumenty];`
C#		`System.Diagnostics.Proces.Start (cesta, hádka);`
F#		`System.Diagnostics.Proces.Start (cesta, hádka);`
Jít		`vykon. běh (cesta, argv, envv, dir, exec.DevNull, exec.DevNull, exec.DevNull)`	`os.Exec (cesta, argv, envv)`
Visual Basic	`Interaction.Shell (příkaz «, WindowStyle »«, isWaitOnReturn »)`
Visual Basic .NET	`Microsoft.VisualBasic.Interaction.Shell (příkaz «, WindowStyle »«, isWaitOnReturn »)`	`System.Diagnostics.Proces.Start (cesta, hádka)`
Xojo	`Shell.Execute (příkaz «, Parametry »)`	`FolderItem.Launch (parametry, aktivovat)`	N / A
D	`std.process.system ("příkaz");`		`std.process.execv (cesta, arglist);`
Jáva		`Runtime.exec (příkaz); nebo nový ProcessBuilder (příkaz).Start();`
JavaScript Hostitel skriptů Windows implementace	`WScript.CreateObject ("WScript.Shell"). Spustit (příkaz «, WindowStyle »«, isWaitOnReturn »);`	`WshShell.Exec (příkaz)`
Společný Lisp	`(uiop: run-program příkaz)`
Systém	`(Systém příkaz)`
ISLISP	N / A	N / A	N / A
Pascal	`Systém(příkaz);`
OCaml	`Příkaz sys příkaz, Unix.open_process_full příkaz env (stdout, stdin, stderr), ...`	`Unix.create_process prog args new_stdin new_stdout new_stderr, ...`	`Unix.execv prog args nebo Unix.execve prog args env`
Standardní ML	`OS.Process.system příkaz`	`Unix.execute (cesta, args)`	`Posix.Process.exec (cesta, args)`
Haskell (GHC)	`System.system příkaz`	`System.Process.runProcess cesta args ...`	`Proces Posix.executeFile cesta Skutečný args ...`
Perl	Systém(příkaz) nebo $ výstup = `příkaz` nebo $ výstup = qx (příkaz)		`exec (cesta, args)`
Rubín	Systém(příkaz) nebo výstup = `příkaz`		`exec (cesta, args)`
PHP	Systém(příkaz) nebo $ výstup = `příkaz` nebo exec (příkaz) nebo projít(příkaz)
Krajta	`os. system (příkaz) nebo subprocess.Popen (příkaz)`	`subprocess.call (["program", "arg1", "arg2", ...])`	`os.execv (cesta, args)`
Slang	`Systém(příkaz)`
Fortran	`VOLEJTE EXECUTE_COMMAND_LINE (PŘÍKAZ «, POČKEJTE» «, EXITSTAT» «, CMDSTAT» «, CMDMSG») ^[A]`
Windows PowerShell	`[Diagnostics.Process] :: Start (příkaz)`	`«Vyvolat položku »Program arg1 arg2…`
Bash shell	výstup=`příkaz` nebo `výstup=$(příkaz)`	`program arg1 arg2…`

^ a Fortran 2008 nebo novější.^[16]

Reference

^ ^A ^b ^C ^d ^E ^F ^G ^h ⁱ ^j ^k ^l ^m ⁿ ^Ó ^str Referenční příručka Ada - jazykové a standardní knihovny; ISO / IEC 8652: 201x (E), "Referenční příručka" (PDF). Archivovány od originál (PDF) dne 2011-04-27. Citováno 2013-07-19.
^ „Common Lisp HyperSpec (TM)“. lispworks.com. Citováno 30. ledna 2017.
^ "www.islisp.info: Specifikace". islisp.info. Archivovány od originál dne 22. ledna 2016. Citováno 30. ledna 2017.
^ ^A ^b "selected_int_kind ve Fortran Wiki". fortranwiki.org. Citováno 30. ledna 2017.
^ "Erlang - typy a specifikace funkcí". erlang.org. Citováno 30. ledna 2017.
^ „Erlang - pokročilý“. erlang.org. Citováno 30. ledna 2017.
^ ^A ^b 8.5 Typ čísla
^ ^A ^b „selected_real_kind ve Fortran Wiki“. fortranwiki.org. Citováno 30. ledna 2017.
^ „Knihovna GNU C: komplexní čísla“. gnu.org. Citováno 30. ledna 2017.
^ „Grammar vb“. Specifikace jazyka Visual Basic. 2016-06-17. Archivováno z původního dne 2019-08-29. Citováno 2019-08-29.
^ „pro ... z“. mozilla.org. Citováno 30. ledna 2017.
^ „Try-Catch for VB“. google.com. Citováno 30. ledna 2017.
^ „Prime rozklad - Rosetta Code“. rosettacode.org. Citováno 30. ledna 2017.
^ „iso_fortran_env ve Fortran Wiki“. fortranwiki.org. Citováno 30. ledna 2017.
^ „Execute a system command - Rosetta Code“. rosettacode.org. Citováno 30. ledna 2017.
^ „EXECUTE_COMMAND_LINE - kompilátor GNU Fortran“. gnu.org. Citováno 30. ledna 2017.

[Ada_RM_2012-1] A ^b ^C ^d ^E ^F ^G ^h ⁱ ^j ^k ^l ^m ⁿ ^Ó ^str Referenční příručka Ada - jazykové a standardní knihovny; ISO / IEC 8652: 201x (E), "Referenční příručka" (PDF). Archivovány od originál (PDF) dne 2011-04-27. Citováno 2013-07-19.

[HyperSpec-2] „Common Lisp HyperSpec (TM)“. lispworks.com. Citováno 30. ledna 2017.

[Specification-3] "www.islisp.info: Specifikace". islisp.info. Archivovány od originál dne 22. ledna 2016. Citováno 30. ledna 2017.

[fortranwiki.org-4] A ^b "selected_int_kind ve Fortran Wiki". fortranwiki.org. Citováno 30. ledna 2017.

[5] "Erlang - typy a specifikace funkcí". erlang.org. Citováno 30. ledna 2017.

[6] „Erlang - pokročilý“. erlang.org. Citováno 30. ledna 2017.

[Javascript_numbers-7] A ^b 8.5 Typ čísla

[ReferenceA-8] A ^b „selected_real_kind ve Fortran Wiki“. fortranwiki.org. Citováno 30. ledna 2017.

[9] „Knihovna GNU C: komplexní čísla“. gnu.org. Citováno 30. ledna 2017.

[10] „Grammar vb“. Specifikace jazyka Visual Basic. 2016-06-17. Archivováno z původního dne 2019-08-29. Citováno 2019-08-29.

[11] „pro ... z“. mozilla.org. Citováno 30. ledna 2017.

[12] „Try-Catch for VB“. google.com. Citováno 30. ledna 2017.

[13] „Prime rozklad - Rosetta Code“. rosettacode.org. Citováno 30. ledna 2017.

[14] „iso_fortran_env ve Fortran Wiki“. fortranwiki.org. Citováno 30. ledna 2017.

[Ada_Execute_Command-15] „Execute a system command - Rosetta Code“. rosettacode.org. Citováno 30. ledna 2017.

[16] „EXECUTE_COMMAND_LINE - kompilátor GNU Fortran“. gnu.org. Citováno 30. ledna 2017.

[1]

[j]

[k]

[C]

[A]

[G]

[b]

[2]

[3]

[F]

[m]

[E]

[d]

[n]

[Ó]

[l]

[i]

[h]

[4]

[5]

[6]

[b]

[F]

[G]

[7]

[C]

[E]

[8]

[b]

[9]

[A]

[A]

[b]

[d]

[F]

[C]

[E]

[A]

[b]

[d]

[C]

[E]

[b]

[A]

[C]

[d]

[E]

[F]

[A]

[10]

[b]

[C]

[d]

[b]

[C]

[A]

[d]

[b]

[11]

[A]

[C]

[d]

[b]

[A]

[12]

[13]

[b]

[A]

[C]

[b]

[d]

[A]

[d]

[b]

[C]

[A]

[b]

[C]

[d]

[E]

[14]

[A]

[b]

[C]

[15]

[A]

[16]