Jämförelse av programmeringsspråk (grundläggande instruktioner)

ett stort antal programmeringsspråk genom att tabulera deras datatyper , deras uttryck , sats och deklarationssyntax och några vanliga operativsystemgränssnitt.

Konventioner i denna artikel

I allmänhet är var , var eller var hur variabelnamn eller andra icke-bokstavliga värden som ska tolkas av läsaren representeras. Resten är bokstavlig kod. Guillemets ( « och » ) omsluter valfria sektioner. Tabb ↹ indikerar ett nödvändigt (blanksteg) indrag.

Observera att tabellerna inte är sorterade lexikografiskt stigande efter programmeringsspråksnamn som standard, och att vissa programmeringsspråk har poster i vissa tabeller men inte andra.

Typ identifierare

Heltal

	8 bitar ( byte )		16 bitar ( kort heltal )		32 bitar		64 bitar ( långt heltal )		Ordstorlek		Godtyckligt exakt ( bignum )
	Signerad	Osignerad	Signerad	Osignerad	Signerad	Osignerad	Signerad	Osignerad	Signerad	Osignerad
Ada	intervall -2**7 .. 2**7 - 1	intervall 0 .. 2**8 - 1 eller mod 2**8	intervall -2**15 .. 2**15 - 1	intervall 0 .. 2**16 - 1 eller mod 2**16	intervall -2**31 .. 2**31 - 1	intervall 0 .. 2**32 - 1 eller mod 2**32	intervall -2**63 .. 2**63 - 1	mod 2**64	Heltal	intervall 0 .. 2**Integer' Size - 1 eller mod Integer' Size	—
ALGOL 68 (variabel bredd)	kort kort int	—	kort int	—	int	—	lång int	—	int	—	lång lång int
									byte och bitar
C ( C99 fast bredd)	int8_t	uint8_t	int16_t	uint16_t	int32_t	uint32_t	int64_t	uint64_t	intptr_t	storlek_t	—
C++ ( C++11 fast bredd)
C ( C99 variabel bredd)	signerad röding	osignerad röding	kort	osignerad kort	lång	osignerad lång	lång lång	osignerad lång lång	int	osignerad int
C++ ( C++11 variabel bredd)
Objective-C ( Kakao )	signerad char eller int8_t	osignerad char eller uint8_t	kort eller int16_t	osignerad kort eller uint16_t	int eller int32_t	osignerad int eller uint32_t	lång lång eller int64_t	unsigned long long eller uint64_t	NHeltal eller lång	NSU Heltal eller osignerad lång
C#	sbyte	byte	kort	kort	int	uint	lång	lång	IntPtr	UIntPtr	System.Numerics. BigInteger (.NET 4.0)
Java	byte	—		röding		—		—	—	—	java.math. BigInteger
Gå	int8	uint8 eller byte	int16	uint16	int32	uint32	int64	uint64	int	uint	big.Int
Rost	i8	u8	i16	u16	i32	u32	i64	u64	isize	använda	—
Snabb	Int8	UInt8	Int16	UInt16	Int32	UInt32	Int64	UInt64	Int	UInt
D	byte	ubyte	kort	kort	int	uint	lång	lång	—	—	BigInt
Vanlig Lisp	(signerad byte 8)	(osignerad byte 8)	(signerad byte 16)	(osignerad byte 16)	(signerad byte 32)	(osignerad byte 32)	(signerad byte 64)	(osignerad byte 64)			bignum
Schema
ISLISP											bignum
Pascal ( FPC )	kortslutning	byte	smallint	ord	longint	långord	int64	qword	heltal	kardinal	—
Visual Basic	—	Byte	Heltal	—	Lång	—	—		—		—
Visual Basic .NET	SByte		Kort	UShort	Heltal	UHeltal	Lång	ULång			System.Numerics .BigInteger (.NET 4.0)
FreeBasic	Byte eller heltal<8>	UByte eller UInteger<8>	Kort eller heltal<16>	UShort eller UInteger<16>	Långt eller heltal<32>	ULong eller UInteger<32>	LongInt eller heltal<64>	ULongInt eller UInteger<64>	Heltal	UHeltal	—
Python 2.x	—		—		—		—		int	—	lång
Python 3.x	—		—		—		—		—		int
Slang	—		—		—		—		—		—
Fortran	HELTAL (KIND = n)	—	HELTAL (KIND = n)	—	HELTAL (KIND = n)	—	HELTAL (KIND = n)	—
PHP	—		—		int	—	int	—	—
Perl 5	—		—		—		—		—		Math::BigInt
Raku	int8	uint8	int16	uint16	int32	uint32	int64	uint64	Int	—
Rubin	—		—		—		—		Fixnum	—	Bignum
Erlang	—		—		—		—		heltal()	—	heltal()
Scala	Byte	—	Kort	Röding	Int	—	Lång	—	—	—	scala.math.BigInt
Frö7	—	—	—	—	—	—	heltal	—	—	—	stort Heltal
Småprat	—		—		—		—		Litet heltal	—	Stort heltal
Windows PowerShell	—		—		—		—		—		—
OCaml	—		—		int32	—	int64	—	int eller nativeint		öppna Big_int;; eller big_int
F#	sbyte	byte	int16	uint16	int32 eller int	uint32		uint64	nativeint	ointressant	bigint
Standard ML	—	Word8.word	—		Int32.int	Word32.word	Int64.int	Word64.word	int	ord	LargeInt.int eller IntInf.int
Haskell ( GHC )	«import Int» eller Int8	«importera Word» eller Word8	«import Int» eller Int16	«importera Word» eller Word16	«import Int» eller Int32	«importera Word» eller Word32	«import Int» eller Int64	«importera Word» eller Word64	Int	«importera Word» eller Word	Heltal
Eiffel	INTEGER_8	NATURLIG_8	INTEGER_16	NATURLIG_16	INTEGER_32	NATURLIG_32	INTEGER_64	NATURLIG_64	HELTAL	NATURLIG	—
COBOL	BINÄRTECKNING «SIGNERAD»	BINÄR-CHAR OSIGNERAD	BINÄR-KORT ​​«SIGNAD»	BINÄR-KORT ​​OSIGNERAD	BINÄR-LÅNG «SIGNAD»	BINÄR-LÅNG OSIGNERAD	BINÄR-DUBBLA "SIGNADE"	BINÄR-DUBBLA OSIGNERAD	—	—	—
Mathematica	—		—		—		—		—		Heltal
Wolfram språk	—		—		—		—		—		Heltal

• ^ a Standardkonstanterna int shorts och int lengths kan användas för att bestämma hur många korta s och långa s som med fördel kan sättas som prefix till short int och long int . De faktiska storlekarna på kort int , int och long int är tillgängliga som konstanterna short max int , max int och long max int etc.
• ^b Används vanligtvis för tecken.
• ^c Språken ALGOL 68, C och C++ anger inte den exakta bredden på heltalstyperna short , int , long och ( C99 , C++11 ) long long , så de är implementeringsberoende. I C och C++ korta , långa och långa långa typer är minst 16, 32 respektive 64 bitar breda, men kan vara fler. Int - typen måste vara minst lika bred som kort och högst lika bred som lång och är vanligtvis bredden på ordstorleken på maskinens processor (dvs. på en 32-bitars maskin är den ofta 32 bitar bred ; på 64-bitars maskiner är den ibland 64 bitar bred). C99 och C++11 definierar också [u]intN_t exakta breddtyper i stdint.h -huvudet. Se C-syntax#Integraltyper för mer information. Dessutom definieras typerna size_t och ptrdiff_t i relation till adressstorleken för att hålla osignerade och signerade heltal tillräckligt stora för att hantera arrayindex och skillnaden mellan pekare.
• ^d Perl 5 har inte distinkta typer. Heltal, flyttal, strängar, etc. betraktas alla som "skalärer".
• ^e PHP har två bibliotek med godtycklig precision. BCMath-biblioteket använder bara strängar som datatyp. GMP-biblioteket använder en intern "resurs"-typ.
• ^f Värdet på n tillhandahålls av den inneboende funktionen SELECTED_INT_KIND .
• ^g ALGOL 68 G:s körtidsalternativ --precision "number" kan ställa in precision för långa långa int s till de nödvändiga "antal" signifikanta siffrorna. Standardkonstanterna long long int width och long long max int kan användas för att bestämma verklig precision .
• ^h COBOL tillåter specificering av en nödvändig precision och kommer automatiskt att välja en tillgänglig typ som kan representera den specificerade precisionen. " PIC S9999 ", till exempel, skulle kräva en signerad variabel med fyra decimalsiffrors precision. Om det anges som ett binärt fält, skulle detta välja en 16-bitars signerad typ på de flesta plattformar.
• ^i Smalltalk väljer automatiskt en lämplig representation för heltal. Vanligtvis finns två representationer, en för heltal som passar den ursprungliga ordstorleken minus valfri taggbit ( SmallInteger ) och en som stöder heltal med godtycklig storlek ( LargeInteger ). Aritmetiska operationer stödjer polymorfa argument och returnerar resultatet i den mest lämpliga kompakta representationen.
• ^j Ada- intervalltyper kontrolleras för gränsöverträdelser vid körning (liksom vid kompileringstid för statiska uttryck). Överträdelser av gränser vid körning leder till ett undantag för "begränsningsfel". Områden är inte begränsade till två potenser. Vanligtvis fördefinierade heltalsundertyper är: Positivt ( intervall 1 .. Integer'Last ) och Natural ( intervall 0 .. Integer'Last ). Short_Short_Integer (8 bitar), Short_Integer (16 bitar) och Long_Integer (64 bitar) är också vanligtvis fördefinierade, men krävs inte av Ada-standarden. Körtidskontroller kan inaktiveras om prestanda är viktigare än integritetskontroller.
• ^k Ada modulo-typer implementerar modularitmetik i alla operationer, dvs inga avståndsöverträdelser är möjliga. Moduler är inte begränsade till två potenser.
• ^l Används vanligtvis för tecken som Javas char.
• ^m int i PHP har samma bredd som lång typ i C har på det systemet.
• ^n Erlang skrivs dynamiskt. Typidentifierarna används vanligtvis för att specificera typer av postfält och argument- och returtyper av funktioner.
• ^o När det överstiger ett ord.

Flytpunkt

	Enkel precision	Dubbel precision	Annan precision	Processorberoende
Ada	Flyta	Long_Float	—
ALGOL 68	verklig	lång äkta	kort äkta , lång lång äkta osv.
C	flyta	dubbel	lång dubbel
C++ (STL)
Objective-C ( Kakao )				CGFloat
C#	flyta		—
Java
Gå	flyta 32	flyta64
Rost	f32	f64
Snabb	Float eller Float32	Dubbel eller Float64	Float80	CGFloat
D	flyta	dubbel		verklig
Vanlig Lisp	enkelflytande	dubbelflytande	flöte, kortflytande, långflytande
Schema
ISLISP
Pascal ( FPC )	enda	dubbel		verklig
Visual Basic	Enda	Dubbel	—
Visual Basic .NET
Xojo
Pytonorm	—	flyta
JavaScript		siffra	—
Slang
Fortran	REAL(KIND = n)
PHP		flyta
Perl
Raku	nummer 32	nummer 64		Num
Rubin	—	Flyta	—
Scala	Flyta	Dubbel
Frö7	—	flyta
Småprat	Flyta	Dubbel
Windows PowerShell
Ocaml	—	flyta	—
F#	flyta 32
Standard ML	—			verklig
Haskell ( GHC )	Flyta	Dubbel
Eiffel	REAL_32	REAL_64
COBOL	FLYTNING-BINÄR-7	FLYTNING-BINÄR-34	FLYT-KORT ​​, FLYT-LÅNG , FLYT-FÖRlängd
Mathematica	—	—		Verklig

• ^a Standardkonstanterna verkliga korta och verkliga längder kan användas för att bestämma hur många korta s och långa s som kan användas som prefix till korta reella och långa reella . De faktiska storlekarna på kort real , real och long real är tillgängliga som konstanterna short max real , max real och long max real etc. Med konstanterna kort liten real , small real och long small real tillgängliga för varje typs maskin epsilon .
• ^b förklaringar av enkel precision uppfylls ofta inte
• ^c Värdet på n tillhandahålls av den inneboende funktionen SELECTED_REAL_KIND .
• ^d ALGOL 68 G:s körtidsalternativ --precision "number" kan ställa in precision för långa långa reala s till de nödvändiga "antal" signifikanta siffrorna. Standardkonstanterna lång lång reell bredd och lång lång max reell kan användas för att bestämma verklig precision .
• ^e Dessa IEEE flyttalstyper kommer att introduceras i nästa COBOL-standard.
• ^f Samma storlek som dubbel på många implementeringar.
• ^g Swift stöder 80-bitars utökad precision med flyttal, motsvarande long double i C-språk.

Komplexa tal

	Heltal	Enkel precision	Dubbel precision	Halv och fyrdubblad precision etc.
Ada	—	Komplex	Komplex	Komplex
ALGOL 68	—	kompl	lång kompl osv.	kort kompl etc. och lång lång kompl osv.
C ( C99 )	—	flytkomplex	dubbelkomplex	—
C++ (STL)	—	std::komplex<float>	std::komplex<double>
C#	—	—	System.Numerics.Complex (.NET 4.0)
Java	—	—	—
Gå	—	komplex64	komplex128
D	—	cfloat	cdubbel
Mål-C	—	—	—
Vanlig Lisp	(komplext heltal)	(komplex enkelflytande)	(komplex dubbelflytande)	komplex
Schema				—
Pascal	—	—
Visual Basic	—	—
Visual Basic .NET	—	—	System.Numerics.Complex (.NET 4.0)
Perl			Matte::Komplex
Raku		komplex64	komplex128	Komplex
Pytonorm			komplex	—
JavaScript	—	—
Slang	—	—
Fortran		KOMPLEX(KIND = n)
Rubin	Komplex	—	Komplex
Scala	—	—	—
Frö7	—	—	komplex
Småprat	Komplex	Komplex	Komplex
Windows PowerShell	—	—
OCaml	—	—	Komplext.t
F#			System.Numerics.Complex (.NET 4.0)
Standard ML	—	—	—
Haskell ( GHC )	—	Complex.Complex Float	Complex.Complex Dubbel
Eiffel	—	—	—
COBOL	—	—	—
Mathematica	Komplex	—	—	Komplex

• ^a Värdet på n tillhandahålls av den inneboende funktionen SELECTED_REAL_KIND .
• ^b Generisk typ som kan instansieras med vilken som helst bastyp med flyttal.

Andra variabeltyper

	Text		Boolean	Uppräkning	Objekt / Universal
	Karaktär	Sträng
Ada	Karaktär	String , Bounded_String , Unbounded_String	Boolean	( punkt 1 , punkt 2 , ... )	taggad nullpost
ALGOL 68	röding	sträng , bytes	bool , bitar	— - Användardefinierad	—
C ( C99 )	char , wchar_t	—	bool	enum «namn» { item 1 , item 2 , ... };	ogiltig *
C++ (STL)		«std::»sträng
Mål-C	unichar	NSString *	BOOL		id
C#	röding	sträng	bool	uppräkningsnamn { objekt 1 « = värde », objekt 2 « = värde » , ... }	objekt
Java		Sträng	booleskt	enum name { item 1 , item 2 , ... }	Objekt
Gå	byte , runa	sträng	bool	const ( objekt 1 = iota objekt 2 ... )	gränssnitt{}
Rost	röding	Sträng	bool	uppräkningsnamn { objekt 1 « = värde », objekt 2 « = värde » , ... }	std::any::Val som helst
Snabb	Karaktär	Sträng	Bool	enum name { case item 1 , item 2 , ... }	Några
D	röding	sträng	bool	enum name { item 1 , item 2 , ... }	std.variant.Variant
Vanlig Lisp	karaktär	sträng	booleskt	( medlemspunkt 1 punkt 2 ... )	t
Schema
ISLISP
Pascal (ISO)	röding	—	booleskt	( punkt 1 , punkt 2 , ... )	—
Objekt Pascal (Delphi)		sträng			variant
Visual Basic	—	Sträng	Boolean	Enum namn post 1 «= värde » post 2 «=     värde» ... Slut Enum	[[Varianttyp|Variant]]
Visual Basic .NET	Röding				Objekt
Xojo	—				Objekt eller variant
Pytonorm	—	str	bool	från enum import Enum klass Namn(Enum): artikel 1 = värde artikel 2 = värde ...	objekt
JavaScript	—	Sträng	Boolean		Objekt
Slang
Fortran	CHARACTER(LAN = *)	CHARACTER(LAN = :), allokerbar	LOGISK(KIND = n)		KLASS(*)
PHP	—	sträng	bool		(typdeklaration utelämnad)
Perl	—				UNIVERSELL
Raku	Röding	Str	Bool	enum name<item 1 item 2 ...> enum name <<:item 1 (value) :item 2 (value) ..>>	Mu
Rubin	—	Sträng	Objekt		Objekt
Scala	Röding	Sträng	Boolean	objektnamn utökas Uppräkning { val objekt 1 , objekt 2 ... = Värde , }	Några
Frö7	röding	sträng	booleskt	const typ : namn är nytt enum item 1 , item 2 , ... end enum;
Windows PowerShell
OCaml	röding	sträng	bool	—	—
F#				typnamn = objekt 1 = värde | _ post 2 = värde | ...	obj
Standard ML				—	—
Haskell ( GHC )	Röding	Sträng	Bool	—	—
Eiffel	KARAKTÄR	STRÄNG	BOOLEAN	—	NÅGRA
COBOL	PIC X	PIC X( stränglängd ) eller PIC X«X...»	PIC 1«( antal siffror )» eller PIC 1«1...»	—	OBJEKTREFERENS
Mathematica	—	Sträng			—

• ^a specifikt, strängar av godtycklig längd och som hanteras automatiskt.
• ^b Detta språk representerar en boolean som ett heltal där false representeras som ett värde på noll och sant av ett värde som inte är noll.
• ^c Alla värden utvärderas till antingen sant eller falskt. Allt i TrueClass utvärderas till sant och allt i FalseClass utvärderas till falskt.
• ^d Detta språk har inte en separat teckentyp. Tecken representeras som strängar med längd 1.
• ^e Uppräkningar i detta språk är algebraiska typer med endast nullära konstruktorer
• ^f Värdet på n tillhandahålls av den inneboende funktionen SELECTED_INT_KIND .

Härledda typer

Array

Ytterligare information: Jämförelse av programmeringsspråk (array)

	fast storlek array		dynamisk storlek array
	endimensionell array	flerdimensionell array	endimensionell array	flerdimensionell array
Ada	array ( <första> .. <last> ) av <typ> eller array ( <diskret_typ> ) av <typ>	array ( <första 1 > .. < sista 1 > , < första 2 > .. < sista 2 > , ... ) av <typ> eller array ( <diskret_typ 1 > , <diskret_typ 2 > , ... ) av <typ>	array ( <diskret_typ> intervall <>) av <typ>	array ( <diskret_typ 1 > intervall <>, <diskret_typ 2 > intervall <>, ... ) av <typ>
ALGOL 68	[ första : sista ] «modename» eller helt enkelt: [ storlek ] «modename»	[ first 1 : last 1 , first 2 : last 2 ] «modename» eller [ first 1 : last 1 ][ first 2 : last 2 ] «modename» etc.	flex[ first : last ] «modename» eller helt enkelt: flex[ storlek ] «modename»	flex[ first 1 : last 1 , first 2 : last 2 ] «modename» eller flex[ first 1 : last 1 ] flex[ first 2 : last 2 ] «modename» osv .
C ( C99 )	typnamn [ storlek ]	typnamn [ storlek 1 ][ storlek 2 ]	skriv * namn eller i ett block: int n = ...; typ namn [ n ]
C++ (STL)	«std::»array < typ, storlek > (C++11)		«std::»vektor < typ >
C#	typ []	typ [,, ... ]	System .Collections .ArrayList eller System .Collections .Generic .List < typ >
Java	typ []	skriv [][] ...	ArrayList eller ArrayList< typ >
D	typ [ storlek ]	typ [ storlek 1 ][ storlek 2 ]	typ []
Gå	typ [ storlek ]	[ storlek 1 ][ storlek 2 ] ...typ	[]typ	[][]typ
Rost	[ typ; storlek ]	[[ typ; storlek 1 ] ; storlek 2 ]	Vec< typ >	Vec<Vec< typ >>
Snabb			[ typ ] eller Array< typ >	[[ typ ]] eller Array<Array< typ >>
Mål-C	NSArray		NSMutableArray
JavaScript	—	—	Array
Vanlig Lisp	(enkel matristyp (dimension))	(enkel array-typ (dimension1 dimension2))	(matristyp (dimension))	(matristyp (dimension1 dimension2))
Schema
ISLISP
Pascal	array[ första .. sista ] av typ	array[ första 1 .. sista 1 ] av array[ första 2 .. sista 2 ] ... av typ eller array[ första 1 .. sista 1 , första 2 .. sista 2 , ... ] av typ	—	—
Objekt Pascal (Delphi)			array av typ	array av array ... av typ
Visual Basic	Dim x( sist ) Som typ	Dim x( sista 1 , sista 2 , ... ) Som typ
Visual Basic .NET	typ ()	typ (,, ... )	System .Collections .ArrayList eller System .Collections .Generic .List (av typ )
Pytonorm			lista
Slang	x = typ [ storlek ];	x = typ [ storlek 1 , storlek 2 , ... ];
Fortran	typ :: namn ( storlek )	typ :: namn ( storlek 1 , storlek 2 ,...)	typ , TILLDELNINGSBAR :: namn (:)	typ , ALLOCATABLE :: namn (:,:,...)
PHP			array
Perl
Raku			Array[ typ ] eller Array av typ
Rubin		x = Array.new( size 1 ){ Array.new( size 2 ) }	Array
Scala	Array[ typ ]	Array[ ... [Array[ typ ]] ... ]	ArrayBuffer[ typ ]
Frö7	array- typ eller array- typ [ idxType ]	array array typ eller array [ idxType ] array [ idxType ] typ	array- typ eller array- typ [ idxType ]	array array typ eller array [ idxType ] array [ idxType ] typ
Småprat	Array		Beställd samling
Windows PowerShell	typ []	typ [,, ... ]
Ocaml	typ array	typ array ... array
F#	typ [] eller typ array	typ [,, ... ]	System .Collections .ArrayList eller System .Collections .Generic .List < typ >
Standard ML	typvektor eller typarray _
Haskell ( GHC )	x = Array.array (0, storlek -1) list_of_association_pairs	x = Array.array ((0, 0, ... ), ( storlek 1 -1, storlek 2 -1, ... )) list_of_association_pairs
COBOL	nivå-nummer typ FÖRKOMMER storlek «TIMES».	endimensionell array definition...	nivå-nummer typ FÖRKOMMER min-storlek TILL max-storlek «TIDER» BEROENDE «PÅ» storlek .	—

• ^a I de flesta uttryck (förutom operatorerna sizeof och & ) konverteras värden för matristyper i C automatiskt till en pekare för dess första argument. Se C-syntax#Arrays för ytterligare information om syntax och pekaroperationer.
• ^b Den C-liknande typen x[] fungerar i Java, men typ [] x är den föredragna formen av matrisdeklaration.
• ^c Subranges används för att definiera gränserna för arrayen.
• ^d JavaScripts array är en speciell typ av objekt.
• ^e DEPENDING ON -satsen i COBOL skapar inte en array med sann variabel längd och kommer alltid att allokera den maximala storleken på arrayen.

Andra typer

	Enkla komposittyper		Algebraiska datatyper	Fackföreningar
	Uppgifter	Tuple uttryck
Ada	typnamnet är «abstrakt» «taggat» « begränsat » [ postfält ; 1 : typ fält 2 : typ ; ... slutrekord | noll post ]	—	Vilken kombination av poster, fackföreningar och uppräkningar som helst (liksom referenser till dessa, som möjliggör rekursiva typer).	typnamn ( variation : diskret_typ ) är postfall variation är när choice_list 1 = > fältnamn 1 : typ ; ... när choice_list 2 => fältnamn 2 : typ ; ... ... slutfall; slutrekord
ALGOL 68	struct ( modnamn «fältnamn», ... );	Nödvändiga typer och operatörer kan användardefinieras		union ( modnamn , ... );
C ( C99 )	struct «namn» { typ namn ; ... };	—	—	union { typnamn ; ... };
Mål-C
C++	struct «namn» { typ namn ; ... };	«std::»tuppel < typ 1 ..typ n >
C#	struct name { typnamn ; ... }	( val 1 , val 2 , ... )		—
Java	—
JavaScript		—
D	struct name { typnamn ; ... }		std.variant.Algebraic !(typ,...)	union { typnamn ; ... }
Gå	struct { «namn» typ ... }
Rost	strukturnamn { namn: typ , ... }	( val 1 , val 2 , ... )	enum name { Foo ( typer ) , ... }	fackföreningsnamn { namn: typ , ... }
Snabb	struct name { var name « : typ» ... }	( «namn 1 : » val 1 , «namn 2 : » val 2 , «namn 3 : » val 3 , ... )	enum name { case Foo« ( typer )» case Bar «( typer )» ... }
Vanlig Lisp	(defstruct namn plats-namn (plats-namn initial-värde) (plats-namn initial-värde: typ typ) ...)	(kons val 1 val 2 )
Schema	—
ISLISP
Pascal	postnamn : typ ; _ ... slut	—	—	postfall typ av värde : ( typer ) ; ... slut
Visual Basic
Visual Basic .NET	Strukturnamn Dim namn Som typ ... Slutstruktur _	( val 1 , val 2 , ... )
Pytonorm	—	«( »val 1 , val 2 , val 3 , ... «)»		—
Slang	struct { namn [=värde], ... }
Fortran	TYP namntyp _ :: namn ... SLUTTYP
PHP	—
Perl	—			—
Raku	—
Rubin	OpenStruct.new({:name => value})
Scala	case class name (« var » namn : typ , ... )	( val 1 , val 2 , val 3 , ... )	abstrakt klassnamn kasusklass Foo ( « parametrar och    ) utökar namnfallsklass Bar (« parametrar ») utökar namn ... »    abstrakt klassnamn fallobjekt Foo utökar namnfallsobjekt Bar utökar namn ... eller eller en kombination av kasusklasser ärendeobjekt
Windows PowerShell
OCaml	typnamn = {« föränderligt » namn : typ ; ... }	«(» val 1 , val 2 , val 3 , ... «)»	typnamn = Foo «av typ » | Bar «av typ » | ...	—
F#
Standard ML	typ namn = { namn : typ , ... }	( val 1 , val 2 , val 3 , ... )	datatypnamn = Foo «av typen » | Bar «av typ » | ...
Haskell	data Namn = Konstr { namn :: typ , ... }		data Namn = Foo « typer » | Bar « typer » | ...
COBOL	nivå-nummer namntyp klausuler . nivå-nummer+n namntypssatser . ...	—	—	namn REDEFINER variabeltyp .

• ^a Endast klasser stöds.
• ^b struct s i C++ är faktiskt klasser, men har standard offentlig synlighet och är också POD- objekt. C++11 utökade detta ytterligare för att få klasser att fungera identiskt med POD-objekt i många fler fall.
• endast ^c par
• ^d Även om Perl inte har poster, eftersom Perls typsystem tillåter att olika datatyper finns i en array, skulle "hashar" (associativa arrayer) som inte har ett variabelt index i praktiken vara detsamma som poster.
• ^e Uppräkningar i detta språk är algebraiska typer med endast nullära konstruktorer

Varierande och konstanta deklarationer

	variabel	konstant	typ synonym
Ada	identifierare : typ« := initial_värde»	identifierare : konstant typ := slutvärde	undertypsidentifierare är typ _
ALGOL 68	modename name« := initial_value »;	modename name = värde ;	mode synonym = modename;
C ( C99 )	typnamn « = initial_value »;	enum{ namn = värde };	typedef typ synonym ;
Mål-C
C++		const typnamn = värde ;
C#	typ namn 1 « = initial_value », name 2 « = initial_value », ... ; eller var name = initial_value ;	const typ namn = värde , namn = värde , ... ; eller skrivskyddat skriv namn = värde , namn = värde , ... ;	använder synonym = typ ;
D	typnamn « = initial_value »; eller autonamn = värde ; _	const typnamn = värde ; eller oföränderlig typnamn = värde ;	alias typ synonym ;
Java	typnamn « = initial_value »;	slutlig typnamn = värde ;	—
JavaScript	var namn « = initial_value »; eller låt namnet « = initial_value »; (sedan ECMAScript 2015)	const namn = värde ; (sedan ECMAScript 2015)
Gå	var namntyp « = initial_value » eller name := initial_value	const namn «typ» = värde	typ synonym typ
Rost	låt mutnamn «: typ »« = initial_value »; statisk mut NAMN : typ = värde ;	låt namnet «: typ »« = initial_value »; const NAMN : typ = värde ; statiskt NAMN : typ = värde ;	typ synonym = typnamn ;
Snabb	var namn «: typ »« = initial_value »	låt namnet «: typ » = värde	typalias synonym = typ
Vanlig Lisp	(defparameter name initial-value ) eller (defvar name initial-value )	(defkonstant namnvärde )	(deftype synonym () ' typ )
Schema	(definiera namn initial_value )
ISLISP	(defglobal name initial_value ) eller (defdynamic name initial_value )	(defkonstant namnvärde )	—
Pascal	namn : typ « = initial_value »	namn = värde	synonym = typ
Visual Basic	Dim namn «Som typ »	Se anteckningar till vänster. Konstanter använder samma syntax och: använd Const istället för Dim har en begränsning till endast vissa primitiva typer Const namn 1 «Som typ » = värde , namn 2 «Som typ» = värde, ...
Visual Basic .NET	Variabeldeklarationssyntaxen för VB.NET är ovanligt svår att beskriva exakt. Med tanke på att det finns identifierarsuffix ("modifierare"): type_character , tillgängligt som ett alternativ till en As- sats för vissa primitiva datatyper; nullable_specificator ; och array_specificator ; och det en modifierad_identifierare är av formen identifierare «typ_tecken» «nullable_specificator» «array_specificator» ; en modified_identifier_list är en kommaseparerad lista med två eller flera förekomster av modified_identifier ; och en deklaratorlista är en kommaseparerad lista över deklaratorer, som kan vara av formen identifierare Som object_creation_expression (objektinitieringsdeklarator) , modified_identifier «Som non_array_type « array_rank_specifier »»« = initial_value» (enkel deklarator) , eller modified_identifier_list «Som «non_array_type «« array_rank_specificator »» (multipel deklarator); Giltiga deklarationssatser har formen Dim declarator_list , där, för semantisk analys, för att konvertera declarator_list till en lista med endast enstaka deklaratorer: As - satserna för varje multipeldeklarator distribueras över dess modified_identifier_list Som ny typ... för varje objektinitieringsdeklarator ersätts med As type = New type... och för vilka, för varje identifierare , en type_character och As -sats visas inte båda; om en As- sats finns, visas inte en array_rank_specificator både som en modifiering av identifieraren och på typen av As -satsen; en omodifierad_typ kan bestämmas genom regeln att, om en type_character eller As -sats finns, är unmodified_type den som specificeras av en sådan konstruktion, och att annars, antingen Option Infer måste vara på och identifieraren måste ha en initializer, i vilket fall unmodified_type är den för initializern, eller Option Strikt måste vara av, i vilket fall unmodified_type är Object ; dess final_type är dess omodifierade_typ före dess modifierare; dess final_type är en giltig typ; och om ett initial_värde finns, antingen Option Strict är aktiverat och initial_value har en utökad konvertering till final_type , eller Alternativet Strikt är avstängt och initial_value har en minskande konvertering till final_type . Om Option Explicit är inaktiverat, kräver variabler inte explicit deklaration; de deklareras implicit när de används: name = initial_value		Importer synonym = typ
Xojo	Dim namn «Som typ »« = initial_value»		—
Pytonorm	namn«: typ» = initial_värde	—	synonym = typ
CoffeeScript	namn = initial_värde
Slang	namn = initial_värde ;		typedef struct {...} typnamn
Fortran	typ namn	typ , PARAMETER :: namn = värde
PHP	$ namn = initial_value ;	define(" namn ", värde ); const name = värde (5,3+)	—
Perl	«mitt» $ namn « = initial_value »;	använd konstant namn => värde ;
Raku	«min « typ »» $namn« = initial_value »;	«min « typ »» konstant namn = värde ;	:: synonym ::= typ
Rubin	namn = initial_värde	Namn = värde	synonym = typ
Scala	var namn «: typ » = initial_value	valnamn «: typ » = värde	typ synonym = typ
Windows PowerShell	«[ typ ]» $ namn = initial_value	—	—
Bash skal	namn= initial_värde	—	—
OCaml	låt namnet « : skriv ref» = ref värde	låt namnet «: typ » = värde	typ synonym = typ
F#	låt föränderligt namn «: typ » = värde
Standard ML	valnamn « : typ ref» = ref värde	valnamn «: typ » = värde
Haskell		« namn :: typ ;» namn = värde	typ Synonym = typ
Vidare	VARIABLE namn (i vissa system använd värdet VARIABLE namn istället)	värde KONSTANT namn
COBOL	nivå-nummer namntyp klausuler .	«0»1 namn KONSTANT «SOM» värde .	nivå-nummer namn typ klausuler «IS» TYPEDEF.
Mathematica	namn= initial_värde	—	—

• ^a Pascal har deklarationsblock. Se funktioner .
• ^b Typer är bara vanliga objekt, så du kan bara tilldela dem.
• ^c I Perl omfångar nyckelordet "min" variabeln i blocket.
• ^d Tekniskt sett deklarerar detta inte namn som en föränderlig variabel – i ML kan alla namn bara bindas en gång; snarare förklarar den namnet för att peka på en "referens" datastruktur, som är en enkel föränderlig cell. Datastrukturen kan sedan läsas och skrivas till med hjälp av ! och := operatorer, respektive.
• ^e Om inget initialvärde anges tilldelas ett ogiltigt värde automatiskt (vilket kommer att utlösa ett körtidsundantag om det används innan ett giltigt värde har tilldelats). Även om detta beteende kan undertryckas rekommenderas det i förutsägbarhetens intresse. Om inget ogiltigt värde kan hittas för en typ (till exempel vid en heltalstyp utan begränsning), väljs istället ett giltigt men förutsägbart värde.
• ^f I Rust, om inget initialvärde ges till en let eller let mut- variabel och den aldrig tilldelas senare, finns det en "oanvänd variabel"-varning . Om inget värde anges för en const eller statisk eller statisk mut- variabel, finns det ett fel. Det finns ett med "globaler utan versaler" för const - variabler utan versaler . Efter att den har definierats kan en statisk mut- variabel endast tilldelas i ett osäkert block eller funktion.

Styrningsflöde

Villkorliga uttalanden

	om	annat om	välj fall	villkorligt uttryck
Ada	if condition then statements «else statements » end if	if condition 1 then statements elsif condition 2 then statements ... «else statements » end if	kasusuttryck är när värdelista 1 => satser när värdelista 2 => satser ... « när andra => satser » slutfall	(om villkor 1 då uttryck 1       elsif villkor 2 då uttryck 2 » ... annars uttryck n )    (falluttryck är när värdelista 1 => uttryck 1 när värdelista 2 => uttryck 2 « ... «när andra => uttryck n » ) eller
Frö7	if condition then statements «else statements » end if	if condition 1 then statements elsif condition 2 then statements ... «else statements » end if	kasusuttryck för när set1 : påståenden ... « annars: påståenden » slutfall
Modula-2	om tillstånd slutar påståenden «annat påståenden » .	om villkor 1 då satser elsif villkor 2 då satser ... «annat uttalanden » slut	case- uttryck av caseLabelList : uttalanden | ... «annat uttalanden » slut
ALGOL 68	om tillstånd då uttalanden «annat uttalanden » fi	if condition then statements elif condition then statements fi	fall byta in påståenden, påståenden«,... ut påståenden » esac	( skick | valueIfTrue | valueIfFalse )
ALGOL 68 (kortfattad form)	( villkor | påståenden «| påståenden» )	( skick | uttalanden |: skick | uttalanden )	( variabel | påståenden,... «| påståenden» )
APL	:If skick instruktioner «:Andra instruktioner » :EndIf	:If skick instruktioner :ElseIf skick instruktioner ... «:Else instruktioner » :EndIf	:Välj uttryck :Case case1 instruktioner ... «:Andra instruktioner » :EndSelect	{ condition : valueIfTrue ⋄ valueIfFalse }
C ( C99 )	if ( villkor ) instruktioner «annan instruktioner » kan instruktionerna vara ett enskilt uttalande eller ett block i form av: { statements }	if ( skick ) instruktioner annat om ( skick ) instruktioner ... «annat instruktioner» eller if ( skick ) instruktioner annars { if ( skick ) instruktioner }	switch ( variabel ) { case case1 : instruktioner «; ha sönder;" ... «standard: instruktioner » }	skick ? valueIfTrue : valueIfFalse
Objective-C
C++ (STL)
D
Java
JavaScript
PHP
C#	om ( villkor ) instruktioner «annan instruktioner » instruktioner kan vara en enskild sats eller ett block i form av: { satser }	om ( villkor ) instruktioner annat om ( villkor ) instruktioner ... «annat instruktioner »	switch ( variabel ) { fall fall 1 : instruktioner « break_or_jump_statement » ... «default: instruktioner break_or_jump_statement » } Alla icke-tomma ärenden måste avslutas med en break eller goto case statement (det vill säga de får inte falla igenom till nästa fall). Standardfallet behöver inte komma sist .	skick ? valueIfTrue : valueIfFalse
Windows PowerShell	om ( villkor ) instruktion «annat instruktioner »	if ( villkor ) { instruktioner } elseif ( villkor ) { instruktioner } ... « else { instruktioner }»	switch ( variabel ) { case1 { instruktioner «break;» } ... «standard { instruktioner }»}
Gå	if condition { instruktioner } «annat { instruktioner }»	if condition { instruktioner } else if condition { instruktioner } ... «else { instruktioner }» eller    switch { case condition : instruktioner ... «default: instruktioner » }	switch variabel { fall fall 1 : instruktioner ... «default: instruktioner » }
Snabb	if condition { instruktioner } «annat { instruktioner }»	if condition { instruktioner } else if condition { instruktioner } ... «else { instruktioner }»	switch variabel { fall fall 1 : instruktioner ... «default: instruktioner » }
Perl	if ( villkor ) { instruktioner } « annat { instruktioner }» eller såvida ( notcondition ) { instruktioner } « annars { instruktioner }»	if ( villkor ) { instruktioner } elsif ( villkor ) { instruktioner } ... «else { instruktioner }» eller såvida ( notcondition ) { instruktioner } elsif ( skick ) { instruktioner } ... « annars { instruktioner }»	använd funktionen "switch"; ... given ( variabel ) { när ( fall 1 ) { instruktioner } ... « standard { instruktioner }» }	skick ? valueIfTrue : valueIfFalse
Raku	if condition { instruktioner } «else { instruktioner }» eller om inte villkor { instruktioner }	if condition { instruktioner } elsif condition { instruktioner } ... «else { instruktioner }	given variabel { när fall 1 { instruktioner } ... «default { instruktioner }» }	skick ?? valueIfTrue !! värdeOmFalse
Rubin	om skick instruktioner «annan instruktioner»	om skick instruktioner elsif skick instruktioner ... «annan instruktioner » slut	fallvariabel när fall 1 instruktioner ... « annan instruktioner » slutar	skick ? valueIfTrue : valueIfFalse
Scala	if ( villkor ) { instruktioner } « annars { instruktioner }»	if ( villkor ) { instruktioner } annat if ( villkor ) { instruktioner } ... « annars { instruktioner }»	expression match { case pattern1 => expression case pattern2 => expression ... «case _ => expression » }	if ( villkor ) valueIfTrue annat värdeIfFalse
Småprat	condition ifTrue: trueBlock «ifFalse: falseBlock » slut			condition ifTrue: trueBlock ifFalse: falseBlock
Vanlig Lisp	(när skick instruktioner ) eller    (om inte tillstånd instruktioner ) eller (om skick (progn instruktioner ) «(progn instruktioner )»)	(cond ( condition1 instruktioner ) ( condition2 instruktioner ) ... «(t instruktioner )»)	(case -uttryck ( case1 instruktioner ) ( case2 instruktioner ) ... «(annars instruktioner )»)	(om test då annat ) eller (cond ( test1 värde1 ) ( test2 värde2 ) ... ))
Schema	(när skick instruktioner ) eller (om skick (börja instruktioner ) «(börja instruktioner )»)	(cond ( condition1 instruktioner ) ( condition2 instruktioner ) ... «(annan instruktioner )»)	(fall ( variabel ) (( fall1 ) instruktioner ) (( fall2 ) instruktioner ) ... «(annan instruktioner )»)	(if condition valueIfTrue valueIfFalse )
ISLISP	(om tillstånd (progn instruktioner ) «(progn instruktioner ) »)	(cond ( condition1 instruktioner ) ( condition2 instruktioner ) ... «(t instruktioner )»)	(case -uttryck ( case1 instruktioner ) ( case2 instruktioner ) ... «(t instruktioner )»)	(if condition valueIfTrue valueIfFalse )
Pascal	om tillstånd börjar instruktionerna slut «annars börja instruktionerna sluta»'	om tillstånd, börja instruktioner slut annat om tillstånd , börja instruktioner slut ... «annat börja instruktioner slut»	fallvariabel av fall1 : instruktioner ... « annat: instruktioner » slut
Visual Basic	Om tillstånd Sedan instruktioner «Andra instruktioner » Slut Om Enkelrad, när instruktioner är instruktion 1 : instruktion 2 : ... : Om tillstånd Sedan instruktioner «Andra instruktioner»	If condition Then instruktioner ElseIf condition Then instruktioner ... «Andra instruktioner » End If Enkelrad: Se anmärkning om C-liknande språk; Else - satsen i en enkelrads If -sats kan innehålla en annan enrads If - sats.	Välj« Case» variabel Case case_pattern 1 instruktioner ... «Case Else instruktioner » Slut Välj	IIf ( condition , valueIfTrue , valueIfFalse )
Visual Basic .NET				If( condition , valueIfTrue , valueIfFalse )
Xojo
Pytonorm	om skick : Tab ↹ instruktioner «annat: Tab ↹ instruktioner»	if condition : Tab ↹ instruktioner elif condition : Tab ↹ instruktioner ... «annat: Tab ↹ instruktioner»	Python 3.10+: matchningsvariabel : Tab ↹ case case1 : Tab ↹ Tab ↹ instruktioner Tab ↹ case case2 : Tab ↹ Tab ↹ instruktioner	Python 2.5+: valueIfTrue if condition else valueIfFalse
Slang	if ( villkor ) { instruktioner } « annars { instruktioner }»	if ( villkor ) { instruktioner } annat if ( villkor ) { instruktioner } ... « annars { instruktioner }»	switch ( variabel ) { case case1 : instruktioner } { case case2 : instruktioner } ...
Fortran	OM ( villkor ) DÅ instruktioner ANDRA instruktioner ENDIF	OM ( villkor ) DÅ instruktioner ELSEIF ( villkor ) DÅ instruktioner ... ANDRA instruktioner ENDIF	SELECT CASE( variabel ) CASE ( case1 ) instruktioner ... CASE DEFAULT instruktioner END SELECT
Vidare	skick OM instruktioner « ANDRA instruktioner » DÅ	skick OM instruktioner ANNAT skick OM instruktioner DÅ DÅ	värde CASE case OF instruktioner ENDOF case OF instruktioner ENDOF default instruktioner ENDCASE	villkor IF valueIfTrue ELSE valueIfFalse THEN
Ocaml	om tillstånd börjar instruktionerna slut «annars börja instruktionerna sluta»	om tillstånd, börja instruktioner slut annat om tillstånd , börja instruktioner slut ... «annat börja instruktioner slut»	matcha värde med mönster1 -> uttryck | mönster2 -> uttryck ... «| _ -> uttryck »	if condition then valueIfTrue else valueIfFalse
F#	Lättviktssyntaxläge: Antingen på en enstaka rad eller med indrag enligt nedan: om villkor så Tab ↹ instruktioner «annat Tab ↹ instruktioner» Utförligt syntaxläge: Samma som Standard ML.	Lättviktssyntaxläge: Antingen på en enda rad eller med indrag enligt nedan: om villkor så Tab ↹ instruktioner elif villkor sedan Tab ↹ instruktioner ... «annat Tab ↹ instruktioner» Utförligt syntaxläge: Samma som Standard ML.
Standard ML	om villkoret då «( »instruktioner « )» annars «( » instruktioner « )»	om villkor så «( »instruktioner « )» annat om villkor då «( » instruktioner « )» ... annars «( » instruktioner « )»	kasusvärde för mönster1 = > uttryck | mönster2 => uttryck ... «| _ => uttryck»
Haskell ( GHC )	om villkor sedan uttryck annat uttryck eller när villkor (gör instruktioner ) eller om inte villkor (gör instruktioner )	resultat | villkor = uttryck | villkor = uttryck | annars = uttryck	kasusvärde för { mönster1 - > uttryck ; mönster2 -> uttryck ; ... «_ -> uttryck» }
Bash skal	if condition-kommando; sedan uttryck «annat uttryck » fi	if condition-kommando; sedan uttryck elif villkor-kommando; sedan uttryck «annat uttryck » fi	case "$variable" i "$condition1" ) kommando... "$condition2" ) kommando... esac
CoffeeScript	om villkor då uttryck «annat uttryck» eller    om villkor uttryck «annat uttryck» eller uttryck om villkor eller       om inte villkor uttryck «annat uttryck» eller uttryck om inte villkor	if condition then expression else if condition then expression «else expression» eller       if condition expression else if condition expression «else expression» eller       unless condition expression else unless condition expression «else expression»	byt uttryck när villkor sedan uttryck annat uttryck eller             byt uttryck när villkor uttryck «annat uttryck»	Alla villkor är uttryck.
COBOL	IF -villkor «DÅ» uttryck «ANSÅ uttryck» .		EVALUERA uttryck «ÄVEN uttryck... » NÄR fall-eller-villkor «ÄVEN fall-eller-villkor...» uttryck ... «NÄR ANNAT uttryck » END-EVALUATE
Rost	if condition { expression }« else { expression }»	if condition { expression } else if condition { expression }« else { expression } »	matcha variabel { mönster1 => uttryck, mönster2 => uttryck, mönster3 => uttryck, «_ => uttryck » }	Alla villkor är uttryck
	om	annat om	välj fall	villkorligt uttryck

• ^a En enskild instruktion kan skrivas på samma rad efter kolon. Flera instruktioner är grupperade i ett block som börjar på en ny rad (Indraget krävs). Syntaxen för det villkorliga uttrycket följer inte denna regel.
• ^b Detta är mönstermatchning och liknar utvalda skiftlägen men inte samma sak. Det används vanligtvis för att dekonstruera algebraiska datatyper .
• ^c På språk av familjen Pascal är semikolon inte en del av påståendet. Det är en separator mellan uttalanden, inte en terminator.
• ^d END-IF kan användas istället för punkten i slutet.
• ^e I Rust kan kommatecken ( , ) i slutet av en matcharm utelämnas efter den sista matcharmen, eller efter valfri matcharm där uttrycket är ett block (slutar i möjligen tomma matchande parenteser {} ) .

Loop uttalanden

	medan loop	gör medan loop	(räknestyrd) för loop	för varje
Ada	medan condition loop- satser slutar loop	loop -satser avslutas när inte villkor slut loop	för index i «omvänd» [första .. sista | discrete_type] loop- satser slut loop	för objekt av «omvänd» iterator loop -satser slut loop eller (för [alla | vissa] [i | av] [första .. sista | diskret_typ | iterator] => predikat )
ALGOL 68	«för index » «från första » «med inkrement » «till sist » «medan tillstånd » gör uttalanden od			för nyckel «to upb list» gör «typnamn val=lista[nyckel];» uttalanden od
	«medan tillstånd » gör uttalanden od	«medan uttalanden; villkor » gör uttalanden od	«för index » «från första » «med inkrement » «till sist » gör uttalanden od
APL	:While condition statements :EndWhile	:Upprepa uttalanden :Tills skick	:For var«s» :I listsatser : EndFor	:For var«s» :InEach list statements :EndFor
C ( C99 )	instruktioner kan vara en enskild sats eller ett block i form av: { satser } while ( villkor ) instruktioner	göra instruktioner medan ( villkor );	för ( «typ» i = första ; i <= sista ; i ++) instruktioner	—
Mål-C				för ( skriv objekt i set ) instruktioner
C++ (STL)				«std::»for_each( start , end , function ) Eftersom C++11 : för ( typ objekt : set ) instruktioner
C#				för varje ( skriv objekt i set ) instruktioner
Java				för ( typ objekt : set ) instruktioner
JavaScript			för (var i = första ; i <= sista ; i ++) instruktioner	Sedan EcmaScript 2015: för (var item of set ) instruktioner
PHP			foreach (range( first , last ) as $i) instruktioner eller för ($i = first ; $i <= last ; $i++) instruktioner	foreach ( ställ in som objekt ) instruktioner eller foreach ( ställ in som nyckel => objekt ) instruktioner
Windows PowerShell			för ($i = första ; $i -le sista ; $i++) instruktioner	för varje ( artikel i set ) instruktioner
D			föreach (i; första ... sista) instruktioner	för varje («typ» objekt; set) instruktioner
Gå	för villkor { instruktioner }		för i := först ; i <= sist ; i ++ { instruktioner }	för nyckel , item := range set { instruktioner }
Snabb	medan skick { instruktioner }	2.x: upprepa { instruktioner } medan villkor 1.x: gör { instruktioner } medan villkor	för i = första ... sista { instruktioner } eller för i = första ..< sista+1 { instruktioner } eller för var i = först ; i <= sist ; i ++ { instruktioner }	för objekt i set { instruktioner }
Perl	while ( condition ) { instruktioner } eller tills ( notcondition ) { instruktioner }	gör { instruktioner } while ( villkor ) eller gör { instruktioner } tills ( notcondition )	för «varje» «$i» ( första .. sist ) { instruktioner } eller för ($i = första ; $i <= sista ; $i++) { instruktioner }	för «varje» «$objekt» ( set ) { instruktioner }
Raku	while condition { instruktioner } eller tills notcondition { instruktioner }	upprepa { instruktioner } medan villkor eller upprepa { instruktioner } tills inte villkor	för första .. sista -> $i { instruktioner } eller loop ($i = första ; $i <= sista ; $i++) { instruktioner }	för set« -> $item» { instruktioner }
Rubin	- medan tillståndsinstruktionerna slutar eller tills notcondition    instruktionerna slutar	börja instruktioner slut medan villkor eller    börja instruktioner slutar tills inte villkor	för i i första .. sista instruktioner slut eller    för i första ... sista+1 instruktioner slut eller första .upto( sista ) { |i| instruktioner }	för objekt i set instruktioner slut eller set .each { | föremål | instruktioner }
Bash skal	medan tillstånd ; göra instruktioner gjorda eller    tills inte villkor ; gör instruktioner gjorda	—	för (( i = första ; i <= sista ; ++ i )) ; gör instruktioner gjorda	för föremål i set ; gör instruktioner gjorda
Scala	while ( villkor ) { instruktioner }	gör { instruktioner } medan ( villkor )	för ( i <- först till sist «av 1») { instruktioner } eller först till sist «av 1» för varje ( i => { instruktioner })	for ( item <- set ) { instruktioner } eller ställ in foreach ( item => { instruktioner })
Småprat	conditionBlock whileTrue: loopBlock	loopBlock doWhile: conditionBlock	först till: sista gör: loopBlock	samling gör: loopBlock
Vanlig Lisp	(loop medan condition gör instruktioner ) eller    (gör () ( notcondition ) instruktioner )	(loop gör instruktioner medan skick )	(slinga för i från första till sista «med 1» gör instruktioner ) eller    (dotimes (i N) instruktioner ) eller    (gör ((i first (1+ i))) ((>=i sist )) instruktioner )	(loop för objekt i lista gör instruktioner ) eller    (loop för objekt över vektor gör instruktioner ) eller    (dolist ( objekt lista ) instruktioner ) eller (mapc funktionslista ) eller (karttyp funktion sekvens )
Schema	(gör () ( notcondition ) instruktioner ) eller (låt loop () (om condition (börja instruktioner (loop))))	(låt loop () ( instruktioner (om tillstånd (loop))))	(gör ((i första (+ i 1))) ((>= i sist )) instruktioner ) eller (låt loop ((i first )) (if (< i last ) (börja instruktioner (loop (+ i 1)) ))))	(för varje (lambda ( artikel ) instruktioner ) lista )
ISLISP	(medan skick instruktioner )	instruktioner för tagbody loop (om skick (gå loop))	(för ((i första (+ i 1))) ((>= i sista )) instruktioner )	(mapc (lambda ( objekt ) instruktioner ) lista )
Pascal	medan skick börjar instruktioner slut	upprepa instruktionerna tills inte villkor ;	för i := första «steg 1» till sista börjar instruktionerna slut;	för artikel i set gör instruktioner
Visual Basic	Gör While - tillståndsinstruktioner Loop eller    Do Until notcondition instruktioner Loop eller    ) While- tillståndsinstruktioner Wend (Visual Basic .NET använder End While istället	Gör instruktioner Loop While condition eller    Gör instruktioner Loop Tills notcondition	jag måste deklareras i förväg. För i = första Till sist 1» instruktioner «Steg Nästa i	För varje artikel I uppsättning instruktioner Nästa punkt
Visual Basic .NET			För i« Som typ» = först Till sist« Steg 1» instruktioner Nästa« i»	För varje objekt« Som typ» I uppsättningsinstruktioner Nästa « objekt»
Xojo	Medan skick instruktioner Wend	Gör tills inte villkor instruktioner Loop eller    Gör instruktioner Slinga tills inte villkor
Pytonorm	medan skick : Tab ↹ instruktioner «annat: Tab ↹ instruktioner»	—	Python 3.x: för i i intervallet( första , sista+1 ): Tab ↹ instruktioner «annat: Tab ↹ instruktioner» Python 2.x: för i i xrange( första , sista+1 ): Tab ↹ instruktioner «annat: Tab ↹ instruktioner»	för artikel i set : Tab ↹ instruktioner «annat: Tab ↹ instruktioner»
Slang	while ( villkor ) { instruktioner } «sedan valfritt block»	gör { instruktioner } medan ( villkor ) «sedan valfritt block»	för (i = först ; i <= sist ; i++) { instruktioner } «sedan valfritt block»	för varje objekt ( set ) «med ( vad )» { instruktioner } «sedan valfritt block»
Fortran	GÖR MEDAN ( skick ) instruktionerna SLUTAR	GÖR instruktioner OM ( villkor ) AVSLUTA ENDDO	DO I = första , sista instruktionerna ENDDO	—
Vidare	BÖRJA «instruktioner» tillstånd MEDAN instruktionerna REPETER	BEGIN instruktioner skick TILL	limit start DO instruktioner LOOP	—
Ocaml	medan skick gör instruktionerna _	—	för i = först till sist gör instruktioner gjorda	Array.iter (roligt objekt -> instruktioner ) array eller List.iter (roligt objekt -> instruktioner ) lista
F#	medan skick gör Tab ↹ instruktioner	—	för i = först till sist gör Tab ↹ instruktioner	för objekt i set gör Tab ↹ instruktioner eller Seq.iter (roligt objekt -> instruktioner ) ställ in
Standard ML	medan skick gör ( instruktioner )	—		Array.app (fn objekt => instruktioner ) array eller app (fn objekt => instruktioner ) lista
Haskell ( GHC )	—		Control.Monad.forM_ [ första .. sista ] (\i -> gör instruktioner )	Control.Monad.forM_ list (\item -> gör instruktioner )
Eiffel	från installation tills instruktionerna för tillståndsslingan slutar
CoffeeScript	medan villkor uttryck eller uttryck medan villkor eller medan villkor sedan uttryck eller    tills villkor uttryck eller uttryck tills villkor till uttryck sedan villkor eller	—	för i i [ första .. sista ] uttrycket eller för i i [ första .. sist ] sedan uttryck eller uttryck för i i [ första .. sist ]	för objekt i set uttryck eller för objekt i set sedan uttryck eller uttryck för objekt i set
COBOL	UTFÖR procedur-1 «GENOM procedur-2 » ««Med» TEST FÖRE» TILL villkor eller    UTFÖR ««Med» TEST FÖRE» TILL villkorsuttryck SLUT -UTFÖR	UTFÖR procedur-1 «GENOM procedur-2 » «MED» TEST EFTER TILL tillstånd eller    UTFÖR «MED» TEST EFTER TILL tillstånd uttryck END-PERFORM	UTFÖR procedur-1 «GENOM procedur-2» VARIERAR i FRÅN första MED inkrement TILL i > sista eller    UTFÖR VARIERANDE i FRÅN först MED inkrement TILL i > sista uttrycket END-PERFORM	—
Rost	medan villkor { uttryck }	loop { expression if condition { break; } }	för i i första .. sist+1 { uttryck } eller    för i i första ..= sista { uttryck }	för objekt i set { expression } eller set .into_iter().for_each(| item | expression);

• ^ett " steg n" används för att ändra loopintervallet. Om " steg " utelämnas, är loopintervallet 1.
• ^b Detta implementerar den universella kvantifieraren ("för alla" eller " $\forall$ ") såväl som den existentiella kvantifieraren ("det finns" eller " $\exists$ ").
• ^c THRU kan användas istället för THROUGH .
• ^d «ÄR» STÖRRE «ÄN» får användas istället för > .
• ^e Typ av uppsättningsuttryck måste implementera egenskapen std::iter::IntoIterator .

Undantag

Ytterligare information: Syntax för undantagshantering

	kasta	hanterare	påstående
Ada	höj exception_name «med string_expression»	start uttalanden undantag när undantagslista 1 => satser; när undantagslista 2 => uttalanden; ... «när andra => uttalanden; » slut	pragma Påstå («Kontrollera =>» boolean_expression ««Meddelande =>» string_expression ») [funktion | förfarande | entry] med Pre => boolean_expression Post => boolean_expression any_type med Type_Invariant => boolean_expression
APL	«sträng_uttryck» ⎕SIGNAL nummer_uttryck	:Trap number«s»_expression statements «:Case number«s»_expression statements » ... «:Else number«s»_expression statements » :EndTrap	«string_expression» ⎕SIGNAL 98/⍨~ tillstånd
C ( C99 )	longjmp ( tillstånd , undantag );	switch ( setjmp ( state )) { fall 0: instruktioner bryta ; fall undantag : instruktioner ... }	hävda( villkor );
C++	kasta undantag ;	prova { instruktioner } fånga «( undantag )» { instruktioner } ...
C#		prova { instruktioner } fånga «( undantag« namn» )» { instruktioner } ... «slutligen { instruktioner }»	System.Diagnostics.Debug.Assert( condition ); eller System.Diagnostics.Trace.Assert( condition );
Java		prova { instruktioner } catch ( undantag ) { instruktioner } ... «slutligen { instruktioner }»	hävda villkor «: beskrivning »;
JavaScript		prova { instruktioner } catch ( undantag ) { instruktioner } « slutligen { instruktioner }»	?
D		prova { instruktioner } catch ( undantag ) { instruktioner } ... «slutligen { instruktioner }»	hävda( villkor );
PHP		prova { instruktioner } catch ( undantag ) { instruktioner } ... «slutligen { instruktioner }»	hävda( villkor );
Slang		prova { instruktioner } fånga «exception» { instruktioner } ... «slutligen { instruktioner }»	?
Windows PowerShell		trap «[ undantag ]» { instruktioner } ... instruktioner eller försök { instruktioner } catch «[ undantag ]» { instruktioner } ... «slutligen { instruktioner }»	[Debug]::Assert( condition )
Mål-C	@kast undantag ;	@försök { instruktioner } @catch ( undantag ) { instruktioner } ... «@slutligen { instruktioner }»	NSAssert( condition , description );
Snabb	kasta undantag ( 2.x)	gör { försök uttryck ... instruktioner } fånga undantag { instruktioner } ... (2.x)	hävda ( villkor «, beskrivning »)
Perl	dö undantag ;	eval { instruktioner }; if ($@) { instruktioner }	?
Raku		prova { instruktioner CATCH { när undantag { instruktioner } ... }}	?
Rubin	höja undantag	börja instruktioner räddningsundantag instruktioner ... «annan instruktioner » «se till instruktioner » slut
Småprat	undantagshöjning _	instruktionBlock på: undantag gör: handlerBlock	hävda: conditionBlock
Vanlig Lisp	(fel "undantag" eller    argument av typtillståndstyp )    ) (       ) feltypsargument ) eller ( fel (	(hanterare-case (progn instruktioner ) ( undantag instruktioner ) ... ) eller       (hanterare-bind ( villkor (lambda instruktioner «invoke-restart restart args» )) ... )	( hävda villkor ) eller    ( hävda villkor «( plats ) «fel»» ) eller (check-type var type )
Schema ( R 6 RS )	(höja undantag )	(vakt (kon ( tillstånd instruktioner ) ... ) instruktioner )	?
ISLISP	(fel "error-string"-objekt ) eller (signalvillkorsförhållande kan fortsätta )	(med-hanterare -formulär* )	?
Pascal	höj Exception.Create()	försök Utom på E: undantag börjar instruktioner slut; slutet;	?
Visual Basic	Err.Höj ERRORNUMBER	Med nytt försök : Vid fel Återuppta Nästa OneInstruction .Catch : Vid fel Gå till 0: Välj ärende .Number Fall SOME_ERRORNUMBER instruktioner Avsluta Välj: Avsluta med '*** Prova klass *** Privat mstrDescription As String Private mlngNumber As Long Public Sub Catch() mstrDescription = Err.Description mlngNumber = Err.Number End Sub Public Property Get Number() As Long Number = mlngNumber End Property Public Property Get Description() Som strängbeskrivning = mstrDescription End Property	Debug.Assert skick
Visual Basic .NET	Kasta undantag eller felkod _	Prova instruktioner Catch« namn Som undantag »« När skick » instruktioner ... «Äntligen instruktioner » Avsluta Försök	System.Diagnostik. Debug.Assert( condition ) eller System.Diagnostics.Trace.Assert( condition )
Xojo	Höj undantag	Prova instruktioner Fånga instruktioner för «undantag» ... «Äntligen instruktioner » Avsluta Försök	—
Pytonorm	höja undantag	försök: Tab ↹ instruktioner utom «undantag» : Tab ↹ instruktioner ... «annat: Tab ↹ instruktioner » «slutligen: Tab ↹ instruktioner»	hävda tillstånd
Fortran	—
Vidare	kod KASTA	xt CATCH (kod eller 0)	—
Ocaml	höja undantag	prova uttryck med mönster -> uttryck ...	hävda tillstånd
F#		prova uttryck med mönster -> uttryck ... eller prova uttryck till slut uttryck
Standard ML	höja undantaget «arg»	uttryckshandtagsmönster = > uttryck ...
Haskell ( GHC )	throw undantag eller throwError uttryck	catch tryExpression catchExpression eller catchError tryExpression catchExpression	hävda villkorsuttryck
COBOL	HÖJ «EXCEPTION» undantag	ANVÄND «EFTER» UNDANTAG OBJEKT klassnamn . eller ANVÄND «EFTER» EO klassnamn . eller ANVÄND «EFTER» EXCEPTION CONDITION undantagsnamn «FIL filnamn» . eller ANVÄND «EFTER» EC undantagsnamn «FIL filnamn» .	—
Rost	Nej		hävda!( villkor )

• ^a Common Lisp tillåter med-simple-restart , restart-case och restart-bind för att definiera omstarter för användning med invoke-restart . Ohanterade förhållanden kan göra att implementeringen visar en omstartsmeny för användaren innan stacken avvecklas.
• ^b Ofångade undantag sprids till den innersta dynamiskt omslutande exekveringen. Undantag sprids inte över uppgifter (såvida inte dessa uppgifter för närvarande är synkroniserade på ett möte).

Andra kontrollflödesbeskrivningar

	utgångsblock (bryta)	Fortsätta	märka	gren ( goto )	returvärde från generator
Ada	avsluta «loop_name» «när tillstånd»	—	etikett :	goto etikett	—
ALGOL 68	värde exit; ...	göra uttalanden; hoppa över utgång; etikett: uttalanden od	etikett: ...	gå till etiketten; ... goto label; ... etikett; ...	avkastning(värde) ( Återuppringning )
APL	:Lämna	:Fortsätta	etikett :	→ etikett eller :GoTo- etikett	—
C ( C99 )	ha sönder;	Fortsätta;	etikett :	goto etikett ;	—
Objective-C
C++ (STL)
D
C#					avkastningsvärde ; _
Java	bryta «etikett» ;	fortsätt «etikett» ;		—
JavaScript					avkastningsvärde «;»
PHP	bryta «nivåer» ;	fortsätt «nivåer» ;		goto etikett ;	avkastning «nyckel =>» värde;
Perl	sista «etikett» ;	nästa «etikett» ;
Raku
Gå	bryta «etikett»	fortsätt «etikett»		goto etikett
Snabb	bryta «etikett»	fortsätt «etikett»		—
Bash skal	bryta «nivåer»	fortsätt «nivåer»	—	—	—
Vanlig Lisp	(retur) eller (retur-from block ) eller (loop-finish)		(tagbody tag ... tag ... )	(gå tagga )
Schema
ISLISP	(retur från block )		(tagbody tag ... tag ... )	(gå tagga )
Pascal (ISO)	—		etikett :	goto etikett ;	—
Pascal ( FPC )	ha sönder;	Fortsätta;
Visual Basic	Avsluta block Alternativt, för metoder, Return	—	etikett :	GoTo- etikett
Xojo		Fortsätt blockera
Visual Basic .NET					Avkastningsvärde _
Pytonorm	ha sönder	Fortsätta	—		avkastningsvärde _
RPG IV	LÄMNA;	ITER;
Slang	ha sönder;	Fortsätta;
Fortran	UTGÅNG	CYKEL	märka	GOTO -etikett	—
Rubin	ha sönder	Nästa
Windows PowerShell	bryta «etikett»	Fortsätta
OCaml	—
F#
Standard ML
Haskell ( GHC )
COBOL	AVSLUTA UTFÖR eller AVSLUTA PARAGRAF eller AVSLUTA AVSNITT eller AVSLUTA.	AVSLUTA UTFÖR CYKEL	etikett «AVSNITT».	GÅ TILL etikett	—

• ^a Pascal har deklarationsblock. Se funktioner .
• ^b -etiketten måste vara ett nummer mellan 1 och 99999.

Funktioner

Se reflektion för att anropa och deklarera funktioner med strängar.

	anropa en funktion	grundläggande/void funktion	värdeåtergivande funktion	nödvändig huvudfunktion
Ada	foo «(parametrar)»	procedur foo «(parametrar)» är startsatser slut foo	funktion foo «(parametrar) » returtyp är startsatser slut foo	—
ALGOL 68	foo «(parametrar)» ;	proc foo = «(parametrar)» void : ( instruktioner );	proc foo = «(parametrar)» rettyp: ( instruktioner ...; retvärde );	—
APL	«parametrar» foo parametrar	foo← { uttalanden }	foo← { uttalanden }	—
C ( C99 )	foo ( «parametrar» )	void foo ( «parametrar» ) { instruktioner }	typ foo ( «parametrar» ) { instruktioner ... returnera värde ; }	«globala deklarationer» int main(«int argc, char *argv[]») { instruktioner }
Objective-C
C++ (STL)
Java				public static void main(String[] args) { instruktioner } eller public static void main(String ... args) { instruktioner }
D				int main(«char[][] args») { instruktioner } eller int main(«string[] args») { instruktioner } eller void main(«char[][] args») { instruktioner } eller void main(« sträng[] args») { instruktioner }
C#		Samma som ovan; alternativt, om bara ett påstående: void foo( «parametrar» ) => uttalande ;	Samma som ovan; alternativt, om det är enkelt nog att vara ett uttryck: void foo( «parametrar» ) => uttryck ;	static void Main(«string[] args») method_body Kan istället returnera int . (börjar med C# 7.1:) Kan returnera Task eller Task<int> , och i så fall kan den vara asynkron .
JavaScript		function foo( «parameters» ) { instruktioner } eller var foo = funktion ( «parameters» ) { instruktioner } eller var foo = new Function ( "«parameter»" , ... , "«sista parametern»" " instruktioner ") ;	function foo( «parametrar» ) { instruktioner ... returnera värde ; }	—
Gå		func foo( «parametrar» ) { instruktioner }	func foo( « parametrar» ) typ { instruktioner ... returvärde }	func main() { instruktioner }
Snabb		func foo( «parametrar» ) { instruktioner }	func foo( « parametrar» ) -> skriv { instruktioner ... returvärde }	—
Vanlig Lisp	(foo «parametrar» )	( defun foo ( «parametrar» ) instruktioner ) eller    (setf (symbol-funktion ' symbol ) funktion )	( defun foo ( «parametrar» ) ... värde )	—
Schema		(definiera (foo parametrar ) instruktioner ) eller (definiera foo ( lambda ( parametrar ) instruktioner ))	(definiera (foo parametrar ) instruktioner... return_value ) eller (definiera foo ( lambda ( parametrar ) instruktioner... return_value ))
ISLISP		( defun foo ( «parametrar» ) instruktioner )	( defun foo ( «parametrar» ) ... värde )
Pascal	foo«( parametrar )»	procedur foo«( parametrar )»; "fram;" «etikettetikettdeklarationer » « konst konstantdeklarationer » «typtypdeklarationer » « var variabeldeklarationer» «lokala funktionsdeklarationer» början instruktioner slut;	funktion foo«( parametrar )»: typ ; "fram;" «etikettetikettdeklarationer » « konst konstantdeklarationer » «typtypdeklarationer » « var variabeldeklarationer» «lokala funktionsdeklarationer» börjar instruktioner ; foo := värde slut;	programnamn ; _ «etikettetikettdeklarationer » « konst konstantdeklarationer » «typtypdeklarationer » « var variabeldeklarationer» «funktionsdeklarationer» börjar instruktioner slut.
Visual Basic	Foo( «parametrar» )	Sub Foo«( parametrar )» instruktioner End Sub	Funktion Foo«( parametrar )»«Som typ» instruktioner Foo = värde Slut Funktion	Sub Main() instruktioner End Sub
Visual Basic .NET			Samma som ovan; alternativt:    Funktion Foo«( parametrar ) »« As type» instruktioner Returvärde End Function As -satsen krävs inte om Option Strict är avstängd . Ett typtecken kan användas istället för As- satsen. Om kontroll lämnar funktionen utan att ett returvärde har specificerats uttryckligen, returnerar funktionen standardvärdet för returtypen.	Sub Main(««ByVal»args() As String») instruktioner End Sub eller    Funktion Main(««ByVal»args() As String») Som heltalsinstruktioner End Function
Xojo
Pytonorm	foo( «parametrar» )	def foo( «parametrar» ): Tab ↹ instruktioner	def foo( « parametrar» ): Tab ↹ instruktioner Tab ↹ returvärde	—
Slang	foo( «parametrar» «;kvalificerare» )	definiera foo ( «parametrar» ) { instruktioner }	definiera foo ( «parametrar» ) { instruktioner ... returnera värde ; }	public define slsh_main () { instruktioner }
Fortran	foo ( «argument» ) CALL sub_foo ( «argument» )	SUBROUTINE sub_foo ( «argument» ) instruktioner AVSLUTA SUBRUTIN	typ FUNCTION foo ( «argument» ) instruktioner ... foo = värde SLUT FUNKTION	PROGRAM huvudinstruktioner AVSLUTA PROGRAMMET
Vidare	«parametrar» FOO	: FOO « stack effekt kommentar: ( före -- ) » instruktioner ;	: FOO « stack effekt kommentar: ( före -- efter ) » instruktioner ;	—
PHP	foo( «parametrar» )	function foo( «parametrar» ) { instruktioner }	function foo( «parametrar» ) { instruktioner ... returnera värde ; }	—
Perl	foo( «parametrar» ) eller &foo«( parametrar )»	sub foo { «min ( parametrar ) = @_;» instruktioner }	sub foo { «min ( parametrar ) = @_;» instruktioner ... «retur» värde ; }
Raku	foo( «parametrar» ) eller &foo«( parametrar )»	«multi »sub foo( parametrar ) { instruktioner }	«vår «typ» »« multi »sub foo( parametrar ) { instruktioner ... «retur» värde ; }
Rubin	foo«( parametrar )»	def foo«( parametrar )» instruktioner slut	def foo«( parametrar )» instruktioner «retur» värde slut
Rost	foo( «parametrar» )	fn foo( «parametrar» ) { instruktioner }	fn foo( «parametrar» ) -> skriv { instruktioner }	fn main() { instruktioner }
Scala	foo «( parametrar )»	def foo «( parametrar )»«: Enhet =» { instruktioner }	def foo «( parametrar )»«: typ» = { instruktioner ... «retur» värde }	def main(args: Array[String]) { instruktioner }
Windows PowerShell	foo «parametrar»	function foo { instruktioner }; eller funktion foo { «param( parametrar )» instruktioner }	funktion foo «( parametrar )» { instruktioner ... returnera värde }; eller funktion foo { «param( parametrar )» instruktioner ... returnera värde }	—
Bash skal	foo «parametrar»	function foo { instruktioner } eller    foo () { instruktioner }	function foo { instruktioner returnerar «exit_code» } eller    foo () { instruktioner return «exit_code» }
		parametrar $ n ( $1 , $2 , $3 , ...) $@ (alla parametrar) $# (antalet parametrar) $0 (det här funktionsnamnet)
OCaml	foo parametrar	låt «rec» foo parametrar = instruktioner	låt «rec» foo parametrar = instruktioner... return_value
F#				[<EntryPoint>] låt huvudarg = instruktioner
Standard ML		fun foo parametrar = ( instruktioner )	fun foo parametrar = ( instruktioner... returvärde )
Haskell		foo parametrar = gör Tab ↹ instruktioner	foo parametrar = returvärde eller foo parametrar = gör Tab ↹ instruktioner Tab ↹ returvärde	«main :: IO ()» main = gör instruktioner
Eiffel	foo ( «parametrar» )	foo ( «parametrar» ) kräver förutsättningar gör instruktioner säkerställer att postvillkoren upphör	foo ( «parametrar» ) : typ kräver förutsättningar gör instruktioner Resultat := värde säkerställ postvillkor slut
CoffeeScript	foo()	foo = ->	foo = -> värde	—
	foo parametrar	foo = () ->	foo = ( parametrar ) -> värde
COBOL	CALL " foo " «ANVÄNDA parametrar» «exception-hantering» « END-CALL »	"IDENTIFIKATIONSDIVISION." PROGRAM-ID. foo . «andra divisioner...» PROCEDUR DIVISION « ANVÄNDA parametrar» . instruktioner .	"IDENTIFIKATIONSDIVISION." PROGRAM-ID/FUNKTION-ID. foo . « andra divisioner... » DATA DIVISION. « andra sektioner... » LÄNKNINGSDEL. « parameterdefinitioner... » variabel-till-retur-definition « andra avsnitt... » PROCEDURDIVISION «ANVÄNDA parametrar» RETURNERA variabel-till-retur . instruktioner .	—
	«FUNCTION» foo«(«parametrar»)»	—

• ^a Pascal kräver " framåt; " för vidarebefordran deklarationer .
• ^b Eiffel tillåter specificering av en applikations rotklass och funktion.
• ^c I Fortran kallas funktions-/subrutinparametrar för argument (eftersom PARAMETER är ett språknyckelord); nyckelordet CALL krävs för subrutiner.
• ^d Istället för att använda "foo" kan en strängvariabel användas istället som innehåller samma värde.

Typkonverteringar

Där sträng är ett decimaltal med tecken:

	sträng till heltal	sträng till långt heltal	sträng till flyttal	heltal till sträng	flytande punkt till sträng
Ada	Integer'Value ( string_expression )	Long_Integer'Value ( string_expression )	Float'Value ( string_expression )	Integer'Image ( integer_expression )	Float'Image ( float_expression )
ALGOL 68 med allmänna och sedan specifika format	Med tidigare deklarationer och association av: string buf := "12345678.9012e34 "; fil proxy; associera(proxy, buff);
	get(proxy, ivar);	get(proxy, livar);	get(proxy, rvar);	put(proxy, ival);	put(proxy, rval);
	getf(proxy, ($g$, ivar)); eller getf(proxy, ($dddd$, ivar));	getf(proxy, ($g$, livar)); eller getf(proxy, ($8d$, livar));	getf(proxy, ($g$, rvar)); eller getf(proxy, ($8d.4dE2d$, rvar));	putf(proxy, ($g$, ival)); eller putf(proxy, ($4d$, ival));	putf(proxy, ($g(bredd, platser, exp)$, rval)); eller putf(proxy, ($8d.4dE2d$, rval));
APL	⍎ string_expression	⍎ string_expression	⍎ string_expression	⍕ heltalsuttryck	⍕ float_expression
C ( C99 )	heltal = atoi ( sträng );	lång = atol ( sträng );	flyta = atof ( sträng );	sprintf ( sträng , "%i", heltal );	sprintf ( string , "%f", float );
Mål-C	heltal = [ sträng intValue];	long = [ sträng longLongValue];	float = [ sträng dubbelvärde];	string = [NSString stringWithFormat :@"%i", heltal ];	string = [NSString stringWithFormat :@"%f", float ];
C++ (STL)	«std::»istringstream( sträng ) >> nummer;			«std::»ostringstream o ; o << antal ; sträng = o .str();
C++11	heltal = « std:: »stoi( sträng );	long = « std:: »stol( string );	float = « std:: »stof( sträng); dubbel = « std:: »stod( sträng );	string = « std:: »to_string( nummer );
C#	heltal = int.Parse ( sträng );	long = long.Parse ( sträng );	float = float.Parse ( sträng ); double = double.Parse ( sträng );	string = nummer .ToString();
D	heltal = std.conv.to!int ( sträng )	long = std.conv.to!long ( sträng )	float = std.conv.to!float ( sträng ) dubbel = std.conv.to!double ( sträng )	sträng = std.conv.to!string ( nummer )
Java	heltal = Integer.parseInt ( sträng );	long = Long.parseLong ( sträng );	float = Float.parseFloat ( sträng ); double = Double.parseDouble ( sträng );	sträng = Integer.toString ( heltal ); string = String.valueOf ( heltal );	sträng = Float.toString ( float ); sträng = Double.toString ( dubbel );
JavaScript	heltal = parseInt( sträng );		float = parseFloat( sträng ); float = nytt nummer ( sträng ); float = Number ( sträng ); flyta = + sträng;	sträng = nummer .toString (); sträng = String ( nummer ); sträng = nummer +""; sträng = `${ nummer }`
Gå	heltal , error = strconv.Atoi( string ) heltal , error = strconv.ParseInt ( string , 10, 0)	long , error = strconv.ParseInt ( string , 10, 64)	float , error = strconv.ParseFloat ( string , 64)	string = strconv.Itoa( heltal ) string = strconv.FormatInt ( heltal , 10) sträng = fmt.Sprint( heltal )	string = strconv.FormatFloat ( float ) string = fmt.Sprint ( float )
Rost	string .parse::<i32>() i32::from_str( string )	string .parse::<i64>() i64::from_str( string )	string .parse::<f64>() f64::from_str( string )	heltal .to_string()	float .to_string()
Vanlig Lisp	(setf heltal (parse-heltal sträng ))		(setf float (läs-från-sträng sträng ))	(setf sträng (Princ-to-string number ))
Schema	(definiera nummer (sträng->nummersträng ) )			(definiera sträng (nummer->strängnummer ) )
ISLISP	(setf heltal (konvertera sträng <heltal>))		(setf float (konvertera sträng <float>))	(setf sträng (konvertera nummer <sträng>))
Pascal	heltal := StrToInt( sträng );		float := StrToFloat( string );	sträng := IntToStr( heltal );	string := FloatToStr( float );
Visual Basic	heltal = CInt( sträng )	long = CLng( string )	float = CSng( sträng ) dubbel = CDbl( sträng )	sträng = CStr( nummer )
Visual Basic .NET (kan använda både VB-syntax ovan och .NET-metoder som visas till höger)	heltal = Integer.Parse ( sträng )	long = Long.Parse ( sträng )	float = Single.Parse ( sträng ) dubbel = Double. Parse ( sträng )	string = nummer .ToString()
Xojo	heltal = Val( sträng )	lång = Val( sträng )	dubbel = Val( sträng ) dubbel = CDbl( sträng )	sträng = CStr( nummer ) eller sträng = Str( nummer )
Pytonorm	heltal = int( sträng )	lång = lång ( sträng )	float = float( string )	sträng = str( nummer )
Slang	heltal = atoi ( sträng );	lång = atol ( sträng );	flyta = atof ( sträng );	sträng = sträng( nummer );
Fortran	LÄS( sträng , format ) nummer			SKRIV( sträng , format ) nummer
PHP	heltal = intervall( sträng ); eller heltal = (int) sträng ;		float = floatval( string ); flyta = (flyta) sträng ;	string = " $nummer "; eller sträng = strval( nummer ); eller sträng = (sträng) nummer ;
Perl	nummer = 0 + sträng;			string = " nummer ";
Raku	nummer = + sträng;			sträng = ~ nummer ;
Rubin	heltal = sträng .to_i eller heltal = heltal( sträng )		float = sträng .to_f float = Float( string )	sträng = nummer .till_s
Scala	heltal = sträng .toInt	lång = sträng .toLong	float = sträng .toFloat dubbel = sträng .toDouble	sträng = nummer .toString
Småprat	heltal := Heltal readFrom: sträng		float := Float readFrom: sträng	sträng := nummer asString
Windows PowerShell	heltal = [int] sträng	lång = [lång] sträng	float = [float] sträng	sträng = [sträng] nummer ; eller sträng = " nummer "; eller sträng = ( nummer ).ToString()
OCaml	låt heltal = int_ av_strängsträng		låt flyta = flyta_ av_strängsträng	låt sträng = sträng_ av_int heltal	låt sträng = sträng_ of_float flyta
F#	låt heltal = int sträng	låt heltal = int64 sträng	låt flyta = flyta sträng	låt sträng = strängnummer
Standard ML	val heltal = Int .fromString sträng		val float = Real .fromString -sträng	val sträng = Int .toString heltal	val sträng = Real .toString float
Haskell ( GHC )	nummer = läs sträng			sträng = visa nummer
COBOL	FLYTTA «FUNKTION» NUMVAL( sträng ) TILL nummer			FLYTTA nummer TILL numeriskt redigerat

• ^a JavaScript använder bara flyttal så det finns vissa tekniska detaljer.
• ^b Perl har inte separata typer. Strängar och siffror är utbytbara.
• ^c NUMVAL-C eller NUMVAL-F kan användas istället för NUMVAL .
• ^ str::parse är tillgänglig för att konvertera alla typer som har en implementering av std::str::FromStr- egenskapen. Både str::parse och FromStr::from_str returnerar ett resultat som innehåller den angivna typen om det inte finns något fel. Turbofishen ( ::<_> ) på str::parse kan utelämnas om typen kan härledas från sammanhanget.

Standardström I/O

	läsa från	skriva till
	stdin	stdout	stderr
Ada	Få ( x )	Sätt ( x )	Lägg (Standard_Error, x )
ALGOL 68	readf(( $format$ , x )); eller getf(stand in, ( $format$ , x ));	printf (( $format$ , x )); eller putf(sticker ut, ( $format$ , x ));	putf(stand error, ( $format$ , x ));
APL	x← ⎕	⎕← x	⍞← x
C ( C99 )	scanf ( format , & x ); eller fscanf (stdin, format & x );	printf ( format , x ); eller fprintf (stdout, format , x );	fprintf (stderr, format , x );
Mål-C	data = [[NSFileHandle fileHandleWithStandardInput] readDataToEndOfFile];	[[NSFileHandle fileHandleWithStandardOutput] writeData:data];	[[NSFileHandle fileHandleWithStandardError] writeData:data];
C++	«std::»cin >> x ; eller «std::»getline(«std::»cin, str );	«std::»cout << x ;	«std::»cerr << x ; eller «std::»täppa << x ;
C#	x = Console.Read(); eller x = Console.ReadLine();	Console.Write( «format , » x ); eller Console.WriteLine( «format , » x );	Console.Error .Write( «format , » x ); eller Console.Error .WriteLine( «format , » x );
D	x = std.stdio.readln()	std.stdio.write( x ) eller std.stdio.writeln( x ) eller std.stdio.writef( format , x ) eller std.stdio.writefln( format , x )	stderr.write( x ) eller stderr.writeln( x ) eller std.stdio .writef(stderr, format , x ) eller std.stdio .writefln(stderr, format , x )
Java	x = System.in.read(); eller x = new Scanner(System.in).nextInt(); eller x = new Scanner(System.in).nextLine();	System.out.print( x ); eller System.out. printf ( format , x ); eller System.out.println( x );	System.err.print( x ); eller System.err. printf ( format , x ); eller System.err.println( x );
Gå	fmt.Scan(& x ) eller fmt. Scanf ( format , & x ) eller x = bufio.NewReader(os.Stdin).ReadString('\n')	fmt.Println( x ) eller fmt. Printf ( format , x )	fmt.Fprintln(os.Stderr, x) eller fmt. Fprintf (os.Stderr, format , x )
Snabb	x = readLine() (2.x)	print( x ) (2.x) println( x ) (1.x)
JavaScript webbläsare		document.write( x )
JavaScript Active Server Pages		Response.Write( x )
JavaScript Windows Script Host	x = WScript.StdIn.Read( chars ) eller x = WScript.StdIn.ReadLine()	WScript.Echo( x ) eller WScript.StdOut.Write( x ) eller WScript.StdOut.WriteLine( x )	WScript.StdErr.Write( x ) eller WScript.StdErr.WriteLine( x )
Vanlig Lisp	(setf x (läsrad))	(princ x ) eller (format t format x )	(princ x *error-output*) eller (format *error-output* format x )
Schema ( R 6 RS )	(definiera x (läsrad))	(visa x ) eller (format #t format x )	(display x (current-error-port)) eller (format (current-error-port) format x )
ISLISP	(setf x (läsrad))	(format (standardutdata) format x )	(format (felutgång) format x )
Pascal	läs( x ); eller readln( x );	skriv( x ); eller skrivln( x );	skriv(stderr, x ); eller writeln(stderr, x );
Visual Basic	Input« prompt ,» x	Skriv ut x eller ? x	—
Visual Basic .NET	x = Console.Read() eller x = Console.ReadLine()	Console.Write( «format ,» x ) eller Console.WriteLine( «format , » x )	Console.Error .Write( «format , »x ) eller Console.Error .WriteLine( «format , » x )
Xojo	x = StandardInputStream.Read() eller x = StandardInputStreame.ReadLine()	StandardOutputStream.Write( x ) eller StandardOutputStream.WriteLine( x )	StdErr.Write( x ) eller StdErr.WriteLine( x )
Python 2.x	x = raw_input( «prompt» )	skriv ut x eller sys.stdout.write( x )	skriv ut >> sys.stderr, x eller sys.stderr.write( x )
Python 3.x	x = input( «prompt» )	print( x« , end=""»)	print( x« , end=""», file=sys.stderr)
Slang	fgets (& x , stdin)	fputs ( x , stdout)	fputs ( x , stderr)
Fortran	READ(*, format ) variabelnamn eller READ(INPUT_UNIT, format ) variabelnamn	WRITE(*, format ) uttryck eller WRITE(OUTPUT_UNIT, format ) uttryck	WRITE(ERROR_UNIT, format ) uttryck
Vidare	buffertlängd ACCEPTERA ( # tecken lästa ) KEY ( char )	buffertlängd TYP char EMIT	—
PHP	$x = fgets (STDIN); eller $x = fscanf (STDIN, format );	skriv ut x ; eller eko x ; eller printf ( format , x );	fprintf (STDERR, format , x );
Perl	$x = <>; eller $x = <STDIN>;	skriv ut x ; eller printf- format , x ;	skriv ut STDERR x ; eller printf STDERR- format , x ;
Raku	$x = $*IN.get;	x .print eller x .say	x .note eller $*ERR.print(x) eller $*ERR.say(x)
Rubin	x = får	sätter x eller printf ( format , x )	$stderr.puts(x) eller $stderr. printf ( format , x )
Windows PowerShell	$x = Read-Host«« -Prompt» text »; eller $x = [Konsoll]::Läs(); eller $x = [Console]::ReadLine()	x ; eller Write-Output x ; eller echo x	Skrivfel x
OCaml	låt x = read_int () eller låt str = read_line () eller Scanf. scanf- format (roligt x ... -> ... )	print_int x eller print_endline str eller Printf. printf format x ...	prerr_int x eller prerr_endline str eller Printf. eprintf format x ...
F#	let x = System.Console.ReadLine()	printf format x ... eller printfn format x ...	eprintf format x ... eller eprintfn format x ...
Standard ML	val str = TextIO.inputLIne TextIO.stdIn	tryck str	TextIO.output (TextIO.stdErr, str )
Haskell ( GHC )	x <- readLn eller str <- getLine	skriv ut x eller putStrLn str	hPrint stderr x eller hPutStrLn stderr str
COBOL	ACCEPTERA x	DISPLAY x

• ^a ALGOL 68 dessutom som "oformaterade" överföringsrutiner : läs , skriv , hämta och lägg .
• ^b får (x) och fgets (x, längd , stdin) läser oformaterad text från stdin. Användning av gets rekommenderas inte.
• ^c sätter (x) och fputs (x, stdout) skriver oformaterad text till stdout.
• ^d fputs(x, stderr) skriver oformaterad text till stderr
• ^e INPUT_UNIT, OUTPUT_UNIT, ERROR_UNIT definieras i modulen ISO_FORTRAN_ENV .

Läser kommandoradsargument

	Argumentvärden	Argumentet räknas	Programnamn / Skriptnamn
Ada	Argument ( n )	Argument_Count	Kommando_namn
C ( C99 )	argv[ n ]	argc	första argumentet
Objective-C
C++
C#	args[ n ]	args.Längd	Assembly.GetEntryAssembly() .Location;
Java		args.längd
D			första argumentet
JavaScript Windows Script Host implementering	WScript.Arguments( n )	WScript.Argument.längd	WScript.ScriptName eller WScript.ScriptFullName
Gå	os.Args[ n ]	len(os.Args)	första argumentet
Rost	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()
Snabb	Process.arguments[ n ] eller Process.unsafeArgv[ n ]	Process.arguments.count eller Process.argc	första argumentet
Vanlig Lisp	?	?	?
Schema ( R 6 RS )	(list-ref (kommandorad) n)	(längd (kommandorad))	första argumentet
ISLISP	—	—	—
Pascal	ParamStr( n )	ParamCount	första argumentet
Visual Basic	Kommando	—	App.Path
Visual Basic .NET	CmdArgs( n )	CmdArgs.Längd	[Assembly].GetEntryAssembly().Location
Xojo	System.CommandLine	(strängtolkning)	Application.ExecutableFile.Name
Pytonorm	sys.argv[ n ]	len(sys.argv)	första argumentet
Slang	__argv[ n ]	__argc	första argumentet
Fortran	DO i = 1 , argc CALL GET_COMMAND_ARGUMENT ( i , argv(i) ) ENDDO	argc = COMMAND_ARGUMENT_COUNT ()	0 RING GET_COMMAND_ARGUMENT ( , progname )
PHP	$argv[ n ]	$argc	första argumentet
Bash skal	$ n ($1, $2, $3, ... ) $@ (alla argument)	$#	$0
Perl	$ARGV[ n ]	skalär(@ARGV)	$0
Raku	@*ARGS[ n ]	@*ARGS.elems	$PROGRAM_NAME
Rubin	ARGV[ n ]	ARGV.storlek	$0
Windows PowerShell	$args[ n ]	$args.Längd	$MyInvocation.MyCommand .Name
OCaml	Sys.argv.( n )	Array.length Sys.argv	första argumentet
F#	argument.[ n ]	args.Längd	Assembly.GetEntryAssembly() .Location
Standard ML	List.nth (CommandLine.arguments (), n)	längd (CommandLine.arguments ())	CommandLine.name ()
Haskell ( GHC )	gör { args <- System.getArgs; returlängd args !! n }	gör { args <- System.getArgs; return length args }	System.getProgName
COBOL			—

• ^a I Rust returnerar std::env::args och std::env::args_os iteratorer, std::env::Args respektive std ::env::ArgsOs . Args konverterar varje argument till en sträng och det får panik om det når ett argument som inte kan konverteras till UTF-8 . ArgsOs returnerar en icke-förlustrepresentation av de råa strängarna från operativsystemet ( std::ffi::OsString ), vilket kan vara ogiltigt UTF-8.
• ^b I Visual Basic är kommandoradsargument inte separerade. Att separera dem kräver en delad funktion Split( string ) .
• ^c COBOL-standarden innehåller inga sätt att komma åt kommandoradsargument, men vanliga kompilatortillägg för att komma åt dem inkluderar att definiera parametrar för huvudprogrammet eller använda ACCEPT -satser.

Utförande av kommandon

	Shell kommando	Kör programmet	Ersätt nuvarande program med nytt kört program
Ada	Inte en del av språkstandarden. Görs vanligtvis av kompilatorpaket eller genom gränssnitt till C eller POSIX .
C	system (" kommando ");		execl ( sökväg , args ); eller execv ( sökväg , arglist );
C++
Mål-C		[NSTask launchedTaskWithLaunchPath:(NSString *)path arguments:(NSArray *)arguments];
C#		System.Diagnostics .Process.Start( sökväg , argstring );
F#
Gå		exec.Run( sökväg , argv , envv , dir , exec.DevNull, exec.DevNull, exec.DevNull)	os.Exec( sökväg , argv , envv )
Visual Basic	Interaction.Shell( kommando «, WindowStyle » «, isWaitOnReturn »)
Visual Basic .NET	Microsoft.VisualBasic .Interaction.Shell( kommando «, WindowStyle » «, isWaitOnReturn »)	System.Diagnostics .Process.Start( sökväg , argstring )
Xojo	Shell.Execute( kommando «, Parametrar »)	FolderItem.Launch( parametrar , aktivera )	—
D	std.process.system(" kommando ");		std.process.execv( sökväg , arglist );
Java		Runtime.exec( kommando ); eller ny ProcessBuilder(kommando).start();
JavaScript Windows Script Host implementering	WScript.CreateObject ("WScript.Shell").Run( kommando «, WindowStyle » «, isWaitOnReturn »);	WshShell.Exec(kommando)
Vanlig Lisp	(uiop:kör- programkommando )
Schema	( systemkommando )
ISLISP	—	—	—
Pascal	system( kommando );
OCaml	Sys.command kommando, Unix.open_process_full kommando env (stdout, stdin, stderr),...	Unix.create_process prog args new_stdin new_stdout new_stderr, ...	Unix.execv prog args eller Unix.execve prog args env
Standard ML	OS.Process.system kommando	Unix.execute ( sökväg , args )	Posix.Process.exec ( sökväg , args )
Haskell ( GHC )	System.system kommando	System.Process .runProcess sökväg args ...	Posix.Process .executeFile sökväg True args ...
Perl	system( kommando ) eller $output = ` kommando ` eller $output = qx( kommando )		exec( sökväg , args )
Rubin	system( kommando ) eller utgång = ` kommando `		exec( sökväg , args )
PHP	system( kommando ) eller $output = ` kommando ` eller exec( kommando ) eller passthru( kommando )
Pytonorm	os.system( kommando ) eller subprocess.Popen( kommando )	subprocess.call( ["program", "arg1", "arg2", ...] )	os.execv( sökväg , args )
Slang	system( kommando )
Fortran	RING EXECUTE_COMMAND_LINE ( ​​KOMMANDO «, VÄNTA » «, EXITSTAT » «, CMDSTAT » «, CMDMSG »)
Windows PowerShell	[Diagnostics.Process]::Start(kommando)	«Invoke-Item» -programmet arg1 arg2 ...
Bash skal	output =` kommando ` eller output =$( kommando )	program arg1 arg2 ...

^a Fortran 2008 eller nyare.