Comparison of programming languages (basic instructions)

This article compares a large number of programming languages by tabulating their data types, their expression, statement, and declaration syntax, and some common operating-system interfaces.

Programming language
comparisons

Conventions of this article

The bold is the literal code. The non-bold is interpreted by the reader. Statements in guillemets (« ... ») are optional. Tab ↹ indicates a necessary indent (with whitespace).

Type identifiers

Integers
8 bit (byte) 16 bit (short integer) 32 bit 64 bit (long integer) Word size Arbitrarily precise (bignum)
Signed Unsigned Signed Unsigned Signed Unsigned Signed Unsigned Signed Unsigned
Ada[1] range -2**7 .. 2**7 - 1[j] range 0 .. 2**8 - 1[j] or mod 2**8[k] range -2**15 .. 2**15 - 1[j] range 0 .. 2**16 - 1[j] or mod 2**16[k] range -2**31 .. 2**31 - 1[j] range 0 .. 2**32 - 1[j] or mod 2**32[k] range -2**63 .. 2**63 - 1[j] mod 2**64[k] Integer[j] range 0 .. 2**Integer'Size - 1[j] or mod Integer'Size[k] N/A
ALGOL 68 (variable-width) short short int[c] N/A short int[c] N/A int[c] N/A long int[c] N/A int[c] N/A long long int [a][g]
bytes & bits
C (C99 fixed-width) 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 fixed-width)
C (C99 variable-width) signed char unsigned char short[c] unsigned short[c] long[c] unsigned long[c] long long[c] unsigned long long[c] int[c] unsigned int[c]
C++ (C++11 variable-width)
Objective-C (Cocoa) signed char
or
int8_t		 unsigned char
or
uint8_t		 short
or
int16_t		 unsigned short
or
uint16_t		 int
or
int32_t		 unsigned int
or
uint32_t		 long long
or
int64_t		 unsigned long long
or
uint64_t		 NSInteger
or
long		 NSUInteger
or
unsigned long
C# sbyte byte short ushort int uint long ulong IntPtr UIntPtr System.Numerics.BigInteger
(.NET 4.0)
Java byte N/A char[b] N/A N/A N/A N/A java.math.BigInteger
Go int8 uint8 or byte int16 uint16 int32 uint32 int64 uint64 int uint big.Int
Rust i8 u8 i16 u16 i32 u32 i64 u64 isize usize N/A
Swift Int8 UInt8 Int16 UInt16 Int32 UInt32 Int64 UInt64 Int UInt
D byte ubyte short ushort int uint long ulong N/A N/A BigInt
Common Lisp[2] (signed-byte 8) (unsigned-byte 8) (signed-byte 16) (unsigned-byte 16) (signed-byte 32) (unsigned-byte 32) (signed-byte 64) (unsigned-byte 64) bignum
Scheme
ISLISP[3] bignum
Pascal (FPC) shortint byte smallint word longint longword int64 qword integer cardinal N/A
Visual Basic N/A Byte Integer N/A Long N/A N/A N/A N/A
Visual Basic .NET SByte Short UShort Integer UInteger Long ULong System.Numerics.BigInteger
(.NET 4.0)
FreeBasic Byte or Integer<8> UByte or UInteger<8> Short or Integer<16> UShort or UInteger<16> Long or Integer<32> ULong or UInteger<32> LongInt or Integer<64> ULongInt or UInteger<64> Integer UInteger N/A
Python 2.x N/A N/A N/A N/A int N/A long
Python 3.x N/A N/A N/A N/A N/A int
S-Lang N/A N/A N/A N/A N/A N/A
Fortran INTEGER(KIND = n)[f] N/A INTEGER(KIND = n)[f] N/A INTEGER(KIND = n)[f] N/A INTEGER(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] Math::BigInt
Raku int8 uint8 int16 uint16 int32 uint32 int64 uint64 Int N/A
Ruby N/A N/A N/A N/A Fixnum N/A Bignum
Erlang[n] N/A N/A N/A N/A integer() N/A integer()[o]
Scala Byte N/A Short Char[l] Int N/A Long N/A N/A N/A scala.math.BigInt
Seed7 N/A N/A N/A N/A N/A N/A integer N/A N/A N/A bigInteger
Smalltalk 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
or
nativeint		 open Big_int;;
big_int
F# sbyte byte int16 uint16 int32 or int uint32 uint64 nativeint unativeint bigint
Standard ML N/A Word8.word N/A Int32.int Word32.word Int64.int Word64.word int word LargeInt.int or
IntInf.int
Haskell (GHC) «import Int»
Int8		 «import Word»
Word8		 «import Int»
Int16		 «import Word»
Word16		 «import Int»
Int32		 «import Word»
Word32		 «import Int»
Int64		 «import Word»
Word64		 Int «import Word»
Word		 Integer
Eiffel INTEGER_8 NATURAL_8 INTEGER_16 NATURAL_16 INTEGER_32 NATURAL_32 INTEGER_64 NATURAL_64 INTEGER NATURAL N/A
COBOL[h] BINARY-CHAR «SIGNED» BINARY-CHAR UNSIGNED BINARY-SHORT «SIGNED» BINARY-SHORT UNSIGNED BINARY-LONG «SIGNED» BINARY-LONG UNSIGNED BINARY-DOUBLE «SIGNED» BINARY-DOUBLE UNSIGNED N/A N/A N/A
Mathematica N/A N/A N/A N/A N/A Integer
Wolfram Language N/A N/A N/A N/A N/A Integer

^a The standard constants int shorts and int lengths can be used to determine how many 'short's and 'long's can be usefully prefixed to 'short int' and 'long int'. The actually size of the 'short int', 'int' and 'long int' is available as constants short max int, max int and long max int etc.
^b Commonly used for characters.
^c The ALGOL 68, C and C++ languages do not specify the exact width of the integer types short, int, long, and (C99, C++11) long long, so they are implementation-dependent. In C and C++ short, long, and long long types are required to be at least 16, 32, and 64 bits wide, respectively, but can be more. The int type is required to be at least as wide as short and at most as wide as long, and is typically the width of the word size on the processor of the machine (i.e. on a 32-bit machine it is often 32 bits wide; on 64-bit machines it is sometimes 64 bits wide). C99 and C++11 also define the [u]intN_t exact-width types in the stdint.h header. SeeC syntax#Integral types for more information. In addition the types size_t and ptrdiff_t are defined in relation to the address size to hold unsigned and signed integeres sufficiently large to handle array indices and the difference between pointers.
^d Perl 5 does not have distinct types. Integers, floating point numbers, strings, etc. are all considered "scalars".
^e PHP has two arbitrary-precision libraries. The BCMath library just uses strings as datatype. The GMP library uses an internal "resource" type.
^f The value of "n" is provided by the SELECTED_INT_KIND[4] intrinsic function.
^g ALGOL 68G's run time option --precision "number" can set precision for long long ints to the required "number" significant digits. The standard constants long long int width and long long max int can be used to determine actual precision.
^h COBOL allows the specification of a required precision and will automatically select an available type capable of representing the specified precision. "PIC S9999", for example, would require a signed variable of four decimal digits precision. If specified as a binary field, this would select a 16-bit signed type on most platforms.
^i Smalltalk automatically chooses an appropriate representation for integral numbers. Typically, two representations are present, one for integers fitting the native word size minus any tag bit (SmallInteger) and one supporting arbitrary sized integers (LargeInteger). Arithmetic operations support polymorphic arguments and return the result in the most appropriate compact representation.
^j Ada range types are checked for boundary violations at run-time (as well as at compile-time for static expressions). Run-time boundary violations raise a "constraint error" exception. Ranges are not restricted to powers of two. Commonly predefined Integer subtypes are: Positive (range 1 .. Integer'Last) and Natural (range 0 .. Integer'Last). Short_Short_Integer (8 bits), Short_Integer (16 bits) and Long_Integer (64 bits) are also commonly predefined, but not required by the Ada standard. Run time checks can be disabled if performance is more important than integrity checks.
^k Ada modulo types implement modulo arithmetic in all operations, i.e. no range violations are possible. Modulos are not restricted to powers of two.
^l Commonly used for characters like Java's char.
^m int in PHP has the same width as long type in C has on that system [c].
^n Erlang is dynamically typed. The type identifiers are usually used to specify types of record fields and the argument and return types of functions.[5]
^o When it exceeds one word.[6]

Floating point
Single precision Double precision Other precision Processor dependent
Ada[1] Float Long_Float N/A
ALGOL 68 real[a] long real[a] short real, long long real, etc.[d]
C float[b] double long double[f]
C++ (STL)
Objective-C (Cocoa) CGFloat
C# float N/A
Java
Go float32 float64
Rust f32 f64
Swift Float
Float32		 Double
Float64		 Float80[g] CGFloat
D float double real
Common Lisp single-float double-float float, short-float, long-float
Scheme
ISLISP
Pascal (Free Pascal) single double real
Visual Basic Single Double N/A
Visual Basic .NET
Xojo
Python N/A float
JavaScript Number[7] N/A
S-Lang
Fortran REAL(KIND = n)[c]
PHP float
Perl
Raku num32 num64 Num
Ruby N/A Float N/A
Scala Float Double
Seed7 N/A float
Smalltalk Float Double
Windows PowerShell
OCaml N/A float N/A
F# float32
Standard ML N/A real
Haskell (GHC) Float Double
Eiffel REAL_32 REAL_64
COBOL FLOAT-BINARY-7[e] FLOAT-BINARY-34[e] FLOAT-SHORT, FLOAT-LONG, FLOAT-EXTENDED
Mathematica N/A N/A Real

^a The standard constants real shorts and real lengths can be used to determine how many 'short's and 'long's can be usefully prefixed to 'short real' and 'long real'. The actually size of the 'short real', 'real' and 'long real' is available as constants short max real, max real and long max real etc. With the constants short small real, small real and long small real available for each type's machine epsilon.
^b declarations of single precision often are not honored
^c The value of "n" is provided by the SELECTED_REAL_KIND[8] intrinsic function.
^d ALGOL 68G's run time option --precision "number" can set precision for long long reals to the required "number" significant digits. The standard constants long long real width and 'long long max real can be used to determine actual precision.
^e These IEEE floating-point types will be introduced in the next COBOL standard.
^f Same size as 'double' on many implementations.
^g Swift supports 80-bit extended precision floating point type, equivalent to long double in C languages.

Complex numbers
Integer Single precision Double precision Half and Quadruple precision etc.
Ada[1] N/A Complex[b] Complex[b] Complex[b]
ALGOL 68 N/A compl long compl etc. short compl etc. & long long compl etc.
C (C99) [9] N/A float complex double complex N/A
C++ (STL) N/A std::complex<float> std::complex<double>
C# N/A N/A System.Numerics.Complex
(.NET 4.0)
Java N/A N/A N/A
Go N/A complex64 complex128
D N/A cfloat cdouble
Objective-C N/A N/A N/A
Common Lisp (complex integer) (complex single-float) (complex double-float) complex
Scheme 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 Math::Complex
Raku complex64 complex128 Complex
Python complex N/A
JavaScript N/A N/A
S-Lang N/A N/A
Fortran COMPLEX(KIND = n)[a]
Ruby Complex N/A Complex
Scala N/A N/A N/A
Seed7 N/A N/A complex
Smalltalk Complex Complex Complex
Windows PowerShell N/A N/A
OCaml N/A N/A Complex.t
F# System.Numerics.Complex
(.NET 4.0)
Standard ML N/A N/A N/A
Haskell (GHC) N/A Complex.Complex Float Complex.Complex Double
Eiffel N/A N/A N/A
COBOL N/A N/A N/A
Mathematica Complex N/A N/A Complex

^a The value of "n" is provided by the SELECTED_REAL_KIND[8] intrinsic function.

^b Generic type which can be instantiated with any base floating point type.

Other variable types
Text Boolean Enumeration Object/Universal
Character String[a]
Ada[1] Character String, Bounded_String, Unbounded_String Boolean ( item1, item2, ... ) tagged null record
ALGOL 68 char string, bytes bool, bits N/A - User defined N/A
C (C99) char, wchar_t N/A bool[b] enum «name» { item1, item2, ... }; void *
C++ (STL) «std::»string
Objective-C unichar NSString * BOOL id
C# char string bool enum name { item1« = value», item2« = value», ... } object
Java String boolean enum name { item1, item2, ... } Object
Go byte, rune string bool 
const (
  item1 = iota
  item2
  ...
)
 interface{}
Rust char String bool 
enum name { item1, item2, ... }
 N/A
Swift Character String Bool enum name { case item1, item2, ... } Any
D char string bool enum name { item1, item2, ... } std.variant.Variant
Common Lisp character string boolean (member item1 item2 ...) t
Scheme
ISLISP
Pascal (ISO) char N/A boolean ( item1, item2, ... ) N/A
Object Pascal (Delphi) string variant
Visual Basic N/A String Boolean 
Enum name
  item1 «= value»
  item2 «= value»
  ...
End Enum
 Variant
Visual Basic .NET Char Object
Xojo N/A Object or Variant
Python N/A[d] str bool 
from enum import Enum
class Name(Enum):
  item1 = value
  item2 = value
  ...
 object
JavaScript N/A[d] String Boolean Object
S-Lang
Fortran CHARACTER(LEN = *) CHARACTER(LEN = :), allocatable LOGICAL(KIND = n)[f] CLASS(*)
PHP N/A[d] string bool (type declaration omitted)
Perl N/A[d] UNIVERSAL
Raku Char Str Bool enum name<item1 item2 ...>
enum name <<:item1(value) :item2(value) ..>>		 Mu
Ruby N/A[d] String Object[c] Object
Scala Char String Boolean 
object name extends Enumeration {
  val item1, item2, ... = Value
}
 Any
Seed7 char string boolean 
const type: name is new enum
  item1,
  item2,
  ...
end enum;
Windows PowerShell
OCaml char string bool N/A[e] N/A
F# item2 = value | ... obj
Standard ML N/A[e] N/A
Haskell (GHC) Char String Bool N/A[e] N/A
Eiffel CHARACTER STRING BOOLEAN N/A ANY
COBOL PIC X PIC X(string length) or PIC X«X...» PIC 1«(number of digits)» or PIC 1«1...» N/A OBJECT REFERENCE
Mathematica N/A[d] String N/A

^a specifically, strings of arbitrary length and automatically managed.
^b This language represents a boolean as an integer where false is represented as a value of zero and true by a non-zero value.
^c All values evaluate to either true or false. Everything in TrueClass evaluates to true and everything in FalseClass evaluates to false.
^d This language does not have a separate character type. Characters are represented as strings of length 1.
^e Enumerations in this language are algebraic types with only nullary constructors
^f The value of "n" is provided by the SELECTED_INT_KIND[4] intrinsic function.

Derived types

Array
Further information: Comparison of programming languages (array)
fixed size array dynamic size array
one-dimensional array multi-dimensional array one-dimensional array multi-dimensional array
Ada[1] array (<first> .. <last>) of <type>
or
array (<discrete_type>) of <type>		 array (<first1> .. <last1>, <first2> .. <last2>, ...) of <type>
or
array (<discrete_type1>, <discrete_type2>, ...) of <type>		 array (<discrete_type> range <>) of <type> array (<discrete_type1> range <>, <discrete_type2> range <>, ...) of <type>
ALGOL 68 [first:last]«modename»
or simply:
[size]«modename»		 [first1:last1, first2:last2]«modename»
or
[first1:last1][first2:last2]«modename»
etc.		 flex[first:last]«modename»
or simply:
flex[size]«modename»		 flex[first1:last1, first2:last2]«modename»
or
flex[first1:last1]flex[first2:last2]«modename» etc.
C (C99) type name[size][a] type name[size1][size2][a] type *name
or within a block:
int n = ...; type name[n]
C++ (STL) «std::»array<type, size>(C++11) «std::»vector<type>
C# type[] type[,,...] System.Collections.ArrayList
or
System.Collections.Generic.List<type>
Java type[][b] type[][]...[b] ArrayList or ArrayList<type>
D type[size] type[size1][size2] type[]
Go [size]type [size1][size2]...type []type [][]type
Rust [type; size] [[type; size1]; size2] Vec<type> Vec<Vec<type>>
Swift [type] or Array<type> [[type]] or Array<Array<type>>
Objective-C NSArray NSMutableArray
JavaScript N/A N/A Array[d]
Common Lisp (simple-array type (dimension)) (simple-array type (dimension1 dimension2)) (array type (dimension)) (array type (dimension1 dimension2))
Scheme
ISLISP
Pascal array[first..last] of type[c] array[first1..last1] of array[first2..last2] ... of type [c]

or
array[first1..last1, first2..last2, ...] of type [c]

 N/A N/A
Object Pascal (Delphi) array of type array of array ... of type
Visual Basic Dim x(last) As type Dim x(last1, last2,...) As type
Visual Basic .NET type() type(,,...) System.Collections.ArrayList
or
System.Collections.Generic.List(Of type)
Python list
S-Lang x = type[size]; x = type[size1, size2, ...];
Fortran type :: name(size) type :: name(size1, size2,...) type, ALLOCATABLE :: name(:) type, ALLOCATABLE :: name(:,:,...)
PHP array
Perl
Raku Array[type] or Array of type
Ruby x = Array.new(size1){ Array.new(size2) } Array
Scala Array[type] Array[...[Array[type]]...] ArrayBuffer[type]
Seed7 array type
or
array [idxType] type		 array array type
or
array [idxType] array [idxType] type		 array type
or
array [idxType] type		 array array type
or
array [idxType] array [idxType] type
Smalltalk Array OrderedCollection
Windows PowerShell type[] type[,,...]
OCaml type array type array ... array
F# type [] or type array type [,,...] System.Collections.ArrayList
or
System.Collections.Generic.List<type>
Standard ML type vector or type array
Haskell (GHC) x = Array.array (0, size-1) list_of_association_pairs x = Array.array ((0, 0,...), (size1-1, size2-1,...)) list_of_association_pairs
COBOL level-number type OCCURS size «TIMES». one-dimensional array definition... level-number type OCCURS min-size TO max-size «TIMES» DEPENDING «ON» size.[e] N/A

^a In most expressions (except the sizeof and & operators), values of array types in C are automatically converted to a pointer of its first argument. See C syntax#Arrays for further details of syntax and pointer operations.
^b The C-like "type x[]" works in Java, however "type[] x" is the preferred form of array declaration.
^c Subranges are used to define the bounds of the array.
^d JavaScript's array are a special kind of object.
^e The DEPENDING ON clause in COBOL does not create a 'true' variable length array and will always allocate the maximum size of the array.

Other types
Simple composite types Algebraic data types Unions
Records Tuple expression
Ada[1] 
type name is «abstract» «tagged» «limited» [record
  field1 : type;
  field2 : type;
  ...
end record | null record]
 N/A Any combination of records, unions and enumerations (as well as references to those, enabling recursive types). 
type name (variation : discrete_type) is record
  case variation is
    when choice_list1 =>
      fieldname1 : type;
      ...
    when choice_list2 =>
      fieldname2 : type;
      ...
    ...
  end case;
end record
ALGOL 68 struct (modename «fieldname», ...); Required types and operators can be user defined union (modename, ...);
C (C99) struct «name» {type name;...}; N/A N/A union {type name;...};
Objective-C
C++ struct «name» {type name;...};[b] «std::»tuple<type1..typen>
C# struct name {type name;...} (val1, val2, ... ) N/A
Java N/A[a]
JavaScript N/A
D struct name {type name;...} std.variant.Algebraic!(type,...) union {type name;...}
Go 
struct {
  «name» type
  ...
}
Rust struct name {name: type, ...} (val1, val2, ... ) enum name { Foo(types), ...} union name {name: type, ...}
Swift 
struct name {
  var name «: type»
  ...
}
 («name1:» val1, «name2:» val2, «name3:» val3, ... ) enum name { case Foo«(types)» case Bar «(types)» ... }
Common Lisp (defstruct name slot-name (slot-name initial-value) (slot-name initial-value :type type) ...) (cons val1 val2)[c]
Scheme N/A
ISLISP
Pascal 
record
  name: type;
  ...
end
 N/A N/A 
record
  case type of
  value: (types);
  ...
end
Visual Basic
Visual Basic .NET 
Structure name
  Dim name As type
  ...
End Structure
 (val1, val2, ... )
Python N/A[a] «(»val1, val2, val3, ... «)» N/A
S-Lang struct {name [=value], ...}
Fortran 
TYPE name
  type :: name
  ...
END TYPE
PHP N/A[a]
Perl N/A[d] N/A
Raku N/A[a]
Ruby OpenStruct.new({:name => value})
Scala case class name(«var» name: type, ...) (val1, val2, val3, ... ) 
abstract class name
  case class Foo(«parameters») extends name
  case class Bar(«parameters») extends name
  ...

or

abstract class name
  case object Foo extends name
  case object Bar extends name
  ...

or combination of case classes and case objects
Windows PowerShell
OCaml type name = {«mutable» name : type;...} «(»val1, val2, val3, ... «)» type name = Foo «of type» | Bar «of type» | ... N/A
F#
Standard ML type name = {name : type,...} (val1, val2, val3, ... ) Bar «of type» | ...
Haskell data Name = Constr {name :: type,...} Bar «types» | ...
COBOL 
level-number name type clauses.
  level-number+n name type clauses.
  ...
 N/A N/A name REDEFINES variable type.

^a Only classes are supported.
^b structs in C++ are actually classes, but have default public visibility and are also POD objects. C++11 extended this further, to make classes act identically to POD objects in many more cases.
^c pair only
^d Although Perl doesn't have records, because Perl's type system allows different data types to be in an array, "hashes" (associative arrays) that don't have a variable index would effectively be the same as records.
^e Enumerations in this language are algebraic types with only nullary constructors

Variable and constant declarations
variable constant type synonym
Ada[1] identifier : type« := initial_value»[e] identifier : constant type := final_value subtype identifier is type
ALGOL 68 modename name« := initial_value»; modename name = value; mode synonym = modename;
C (C99) type name« = initial_value»; enum{ name = value }; typedef type synonym;
Objective-C
C++ const type name = value;
C# type name1« = initial_value», name2« = initial_value», ... ; or
var name = initial_value;		 const type name = value, name = value, ... ; or
readonly type name = value, name = value, ... ;		 using synonym = type;
D type name« = initial_value»; or
auto name = value;		 const type name = value; or
immutable type name = value;		 alias type synonym;
Java type name« = initial_value»; final type name = value; N/A
JavaScript var name« = initial_value»; or
let name« = initial_value»; (since ECMAScript 2015)		 const name = value; (since ECMAScript 2015)
Go var name type« = initial_value» or
name := initial_value		 const name «type» = value type synonym type
Rust[f] let mut name«: type»« = initial_value»;
static mut NAME: type = value;		 let name«: type»« = initial_value»;
const NAME: type = value;

static NAME: type = value;		 type synonym = typename;
Swift var name« : type»« = initial_value» let name «: type» = value typealias synonym = type
Common Lisp (defparameter name initial-value) or
(defvar name initial-value)		 (defconstant name value) (deftype synonym () 'type)
Scheme (define name initial_value)
ISLISP (defglobal name initial_value) or
(defdynamic name initial_value)		 (defconstant name value) N/A
Pascal[a] name: type« = initial_value» name = value synonym = type
Visual Basic Dim name «As type» See notes to left.

Constants use the same syntax, and:

  • use Const instead of Dim
  • have a restriction to only certain primitive types

Const name1 «As type» = value, name2 «As type» = value, ...
Visual Basic .NET[10] The variable declaration syntax of VB.NET is surprisingly difficult to precisely describe.

Given that there exist the identifier suffixes ("modifiers"):

  • type_character, available as an alternative to an As clause for some primitive data types;
  • nullable_specifier; and
  • array_specifier;

and that

  • a modified_identifier is of the form identifier«type_character»«nullable_specifier»«array_specifier»;
  • a modified_identifier_list is a comma-separated list of two or more occurrences of modified_identifier; and
  • a declarator_list is a comma-separated list of declarators, which can be of the form
    • identifier As object_creation_expression (object initializer declarator),
    • modified_identifier« As non_array_type«array_rank_specifier»»« = initial_value» (single declarator), or
    • modified_identifier_list« As «non_array_type««array_rank_specifier»» (multiple declarator);

valid declaration statements are of the form

Dim declarator_list,

where, for the purpose of semantic analysis, to convert the declarator_list to a list of only single declarators:

The As clauses of each multiple declarator is distributed over its modified_identifier_list
The As New type... of each object initializer declarator is replaced with As type = New type...

and for which, for each identifier,

  • a type_character and As clause do not both appear;
  • if an As clause is present,
    • an array_rank_specifier does not appear both as a modification of the identifier and on the type of the As clause;
  • an unmodified_type can be determined, by the rule that,
    • if a type_character or As clause is present,
      • unmodified_type is that specified by such construct,
    • and that otherwise,
      • either Option Infer must be on and the identifier must have an initializer, in which case unmodified_type is that of the initializer, or
      • Option Strict must be off, in which case unmodified_type is Object;
  • its final_type is its unmodified_type prepended before its modifiers;
  • its final_type is a valid type; and
  • if an initial_value is present,
    • either Option Strict is on and initial_value has a widening conversion to final_type, or
    • Option Strict is off and initial_value has a narrowing conversion to final_type.

If Option Explicit is off, variables do not require explicit declaration; they are declared implicitly when used:

name = initial_value

 Imports synonym = type
Xojo Dim name «As type»« = initial_value» N/A
Python name = initial_value N/A synonym = type[b]
CoffeeScript N/A
S-Lang name = initial_value; typedef struct {...} typename
Fortran type name type, PARAMETER :: name = value
PHP $name = initial_value; define("name", value);
const name = value (5.3+)		 N/A
Perl «my» $name« = initial_value»;[c] use constant name => value;
Raku «my «type»» $name« = initial_value»;[c] «my «type»» constant name = value; ::synonym ::= type
Ruby name = initial_value Name = value synonym = type[b]
Scala var name«: type» = initial_value val name«: type» = value type synonym = type
Windows PowerShell «[type] »$name = initial_value N/A N/A
Bash shell name=initial_value N/A N/A
OCaml let name« : type ref» = ref value[d] let name «: type» = value type synonym = type
F# let mutable name« : type» = value
Standard ML val name« : type ref» = ref value[d] val name «: type» = value
Haskell «name::type;» name = value type Synonym = type
Forth VARIABLE name (in some systems use value VARIABLE name instead) value CONSTANT name
COBOL level-number name type clauses. «0»1 name CONSTANT «AS» value. level-number name type clauses «IS» TYPEDEF.
Mathematica name=initial_value N/A N/A

^a Pascal has declaration blocks. See functions.
^b Types are just regular objects, so you can just assign them.
^c In Perl, the "my" keyword scopes the variable into the block.
^d Technically, this does not declare name to be a mutable variable—in ML, all names can only be bound once; rather, it declares name to point to a "reference" data structure, which is a simple mutable cell. The data structure can then be read and written to using the ! and := operators, respectively.
^e If no initial value is given, an invalid value is automatically assigned (which will trigger a run-time exception if it used before a valid value has been assigned). While this behaviour can be suppressed it is recommended in the interest of predictability. If no invalid value can be found for a type (for example in case of an unconstraint integer type), a valid, yet predictable value is chosen instead.
^f In Rust, if no initial value is given to a let or let mut variable and it is never assigned to later, there is an "unused variable" warning. If no value is provided for a const or static or static mut variable, there is an error. There is a "non-upper-case globals" error for non-uppercase const variables. After it is defined, a static mut variable can only be assigned to in an unsafe block or function.

Control flow

Conditional statements
if else if select case conditional expression
Ada[1] 
if condition then
  statements
«else
  statements»
end if
 
if condition1 then
  statements
elsif condition2 then
  statements
...
«else
  statements»
end if
 
case expression is
  when value_list1 => statements
  when value_list2 => statements
  ...
  «when others => statements»
end case
 
(if condition1 then
  expression1
«elsif condition2 then
  expression2»
...
else
  expressionn
 )

or

 (case expression is
   when value_list1 => expression1
   when value_list2 => expression2
   ...
   «when others => expressionn»
)
Seed7 
if condition then
  statements
«else
  statements»
end if

if condition1 then

  statements
elsif condition2 then
  statements
...
«else
  statements»
end if
 
case expression of
  when set1 : statements
  ...
  «otherwise: statements»
end case
Modula-2 
if condition then
  statements
«else
  statements»
end
 
if condition1 then
  statements
elsif condition2 then
  statements
...
«else
  statements»
end
 
case expression of
  caseLabelList : statements |
  ...
  «else statements»
end
ALGOL 68 if condition then statements «else statements» fi if condition then statements elif condition then statements fi case switch in statements, statements«,... out statements» esac 
( condition | valueIfTrue | valueIfFalse )
ALGOL 68
(brief form)		 
( condition | statements «| statements» )
 
( condition | statements |: condition |  statements )
 
( variable | statements,... «| statements» )
APL 
:If condition
  instructions
«:Else
  instructions»
:EndIf
 
:If condition
  instructions
:ElseIf condition
  instructions
...
«:Else
  instructions»
:EndIf
 
:Select expression
  :Case case1
    instructions
  ...
  «:Else
    instructions»
:EndSelect
 {condition:valueIfTrue ⋄ valueIfFalse}
C (C99) and:
  • Objective-C
  • C++ (STL)
  • D
  • Java
  • JavaScript
  • PHP
 
if (condition) instructions
«else instructions»

instructions can be a single statement or a block in the form of: { statements }

 
if (condition) instructions
else if (condition) instructions
...
«else instructions»

or 

if (condition) instructions
else { if (condition) instructions }
 
switch (variable) {
  case case1: instructions «; break;»
  ...
  «default: instructions»
}
 condition ? valueIfTrue : valueIfFalse
C# 
if (condition) instructions
«else instructions»

instructions can be a single statement or a block in the form of: { statements }

 
if (condition) instructions
else if (condition) instructions
...
«else instructions»
 
switch (variable)
{
  case case1:
    instructions
    «break_or_jump_statement»
  ...
  «default:
    instructions
    break_or_jump_statement»
}

All non-empty cases must end with a break or goto case statement (that is, they are not allowed to fall-through to the next case). The default case is not required to come last.

condition ? valueIfTrue : valueIfFalse
Windows PowerShell 
if (condition) instruction
«else instructions»
 
if (condition) { instructions }
elseif (condition) { instructions }
...
«else { instructions }»
 
switch (variable) { case1{instructions «break;» } ... «default { instructions }»}
Go 
if condition {instructions}
«else {instructions}»
 
if condition {instructions}
else if condition {instructions}
...
«else {instructions}»

or

switch {
  case condition: instructions
  ...
  «default: instructions»
}
 
switch variable {
  case case1: instructions
  ...
  «default: instructions»
}
Swift 
if condition {instructions}
«else {instructions}»
 
if condition {instructions}
else if condition {instructions}
...
«else {instructions}»
 
switch variable {
  case case1: instructions
  ...
  «default: instructions»
}
Perl 
if (condition) {instructions}
«else {instructions}»

or

unless (notcondition) {instructions}
«else {instructions}»
 
if (condition) {instructions}
elsif (condition) {instructions}
...
«else {instructions}»

or

unless (notcondition) {instructions}
elsif (condition) {instructions}
...
«else {instructions}»
 
use feature "switch";
...
given (variable) {
  when (case1) { instructions }
  ...
  «default { instructions }»
}
 condition ? valueIfTrue : valueIfFalse
Raku 
if condition {instructions}
«else {instructions}»

or

unless notcondition {instructions}
 
if condition {instructions}
elsif condition {instructions}
...
«else {instructions}
 
given variable {
  when case1 { instructions }
  ...
  «default { instructions }»
}
 condition ?? valueIfTrue !! valueIfFalse
Ruby 
if condition
  instructions
«else
  instructions»
 
if condition
  instructions
elsif condition
  instructions
...
«else
  instructions»
end
 
case variable
  when case1
    instructions
  ...
  «else
    instructions»
end
 condition ? valueIfTrue : valueIfFalse
Scala 
if (condition) {instructions}
«else {instructions}»
 
if (condition) {instructions}
else if (condition) {instructions}
...
«else {instructions}»
 
expression match {
  case pattern1 => expression
  case pattern2 => expression
  ...
  «case _ => expression»
}[b]
 if (condition) valueIfTrue else valueIfFalse
Smalltalk 
condition ifTrue:
  trueBlock
«ifFalse:
  falseBlock»
end
 condition ifTrue: trueBlock ifFalse: falseBlock
Common Lisp 
(when condition
  instructions)

or

(unless condition
  instructions)

or

(if condition
  (progn instructions)
  «(progn instructions)»)
 
(cond (condition1 instructions)
  (condition2 instructions)
  ...
  «(t instructions)»)
 
(case expression
  (case1 instructions)
  (case2 instructions)
  ...
  «(otherwise instructions)»)
 
(if test then else)

or

(cond (test1 value1) (test2 value2) ...))
Scheme 
(when condition instructions)

or

(if condition (begin instructions) «(begin instructions)»)
 (cond (condition1 instructions) (condition2 instructions) ... «(else instructions)») (case (variable) ((case1) instructions) ((case2) instructions) ... «(else instructions)») (if condition valueIfTrue valueIfFalse)
ISLISP 
(if condition
  (progn instructions)
  «(progn instructions)»)
 
(cond (condition1 instructions)
  (condition2 instructions)
  ...
  «(t instructions)»)
 
(case expression
  (case1 instructions)
  (case2 instructions)
  ...
  «(t instructions)»)
 (if condition valueIfTrue valueIfFalse)
Pascal 
if condition then begin
  instructions
end
«else begin
  instructions
end»[c]
 
if condition then begin
  instructions
end
else if condition then begin
  instructions
end
...
«else begin
  instructions
end»[c]
 
case variable of
  case1: instructions
  ...
  «else: instructions»
end[c]
Visual Basic 
If condition Then
  instructions
«Else
  instructions»
End If

Single-line, when instructions are instruction1 : instruction2 : ...:

If condition Then instructions «Else instructions»
 
If condition Then
  instructions
ElseIf condition Then
  instructions
...
«Else
  instructions»
End If

Single-line:

See note about C-like languages; the Else clause of a single-line If statement can contain another single-line If statement.

 
Select« Case» variable
  Case case_pattern1
    instructions
  ...
  «Case Else
    instructions»
End Select
 IIf(condition, valueIfTrue, valueIfFalse)
Visual Basic .NET If(condition, valueIfTrue, valueIfFalse)
Xojo
Python [a] 
if condition :
Tab ↹ instructions
«else:
Tab ↹ instructions»
 
if condition :
Tab ↹ instructions
elif condition :
Tab ↹ instructions
...
«else:
Tab ↹ instructions»
 Python 2.5+: 
valueIfTrue if condition else valueIfFalse
S-Lang if (condition) { instructions } «else { instructions }» if (condition) { instructions } else if (condition) { instructions } ... «else { instructions }» switch (variable) { case case1: instructions } { case case2: instructions } ...
Fortran 
IF (condition) THEN
  instructions
ELSE
  instructions
ENDIF
 
IF (condition) THEN 
  instructions
ELSEIF (condition) THEN
  instructions
...
ELSE
  instructions
ENDIF
 
SELECT CASE(variable)
  CASE (case1)
    instructions
  ...
  CASE DEFAULT
    instructions
END SELECT
Forth condition IF instructions « ELSE instructions» THEN condition IF instructions ELSE condition IF instructions THEN THEN 
value CASE
  case OF instructions ENDOF
  case OF instructions ENDOF
    default instructions
ENDCASE
 condition IF valueIfTrue ELSE valueIfFalse THEN
OCaml if condition then begin instructions end «else begin instructions end» if condition then begin instructions end else if condition then begin instructions end ... «else begin instructions end» 
match value with 
  pattern1 -> expression
  | pattern2 -> expression
  ...
  «| _ -> expression»[b]
 
if condition then valueIfTrue else valueIfFalse
F# Lightweight syntax mode:

Either on a single line or with indentation as shown below:

if condition then
Tab ↹ instructions
«else
Tab ↹ instructions»

Verbose syntax mode:

Same as Standard ML (below).

 Lightweight syntax mode:

Either on a single line or with indentation as shown below:

if condition then
Tab ↹ instructions
elif condition then
Tab ↹ instructions
...
«else
Tab ↹ instructions»

Verbose syntax mode:

Same as Standard ML (below).

Standard ML 
if condition then «(»instructions «)»
else «(» instructions «)»
 
if condition then «(»instructions «)»
else if condition then «(» instructions «)»
...
else «(» instructions «)»
 
case value of
  pattern1 => expression
  | pattern2 => expression
  ...
  «| _ => expression»[b]
Haskell (GHC) 
if condition then expression else expression

or

when condition (do instructions)

or

unless notcondition (do instructions)
 
result | condition = expression
  | condition = expression
  | otherwise = expression
 
case value of {
  pattern1 -> expression;
  pattern2 -> expression;
  ...
  «_ -> expression»
}[b]
Bash shell 
if condition-command; then
  expression
«else
  expression»
fi
 
if condition-command; then
  expression
elif condition-command; then
  expression
«else
  expression»
fi
 
case "$variable" in
  "$condition1" )
    command...
  "$condition2" )
    command...
esac
CoffeeScript 
if condition then expression «else expression»

or

if condition
  expression
«else
  expression»

or

expression if condition

or

unless condition
  expression
«else
  expression»

or

expression unless condition
 
if condition then expression else if condition then expression «else expression»

or

if condition
  expression
else if condition
  expression
«else
  expression»

or

unless condition
  expression
else unless condition
  expression
«else
  expression»
 
switch expression
  when condition then expression
  else expression

or

switch expression
  when condition
    expression
  «else
    expression»
 All conditions are expressions.
COBOL 
IF condition «THEN»
  expression
«ELSE
  expression».[d]
 
EVALUATE expression «ALSO expression...»
  WHEN case-or-condition «ALSO case-or-condition...»
    expression
  ...
  «WHEN OTHER
    expression»
END-EVALUATE
if else if select case conditional expression

^a A single instruction can be written on the same line following the colon. Multiple instructions are grouped together in a block which starts on a newline (The indentation is required). The conditional expression syntax does not follow this rule.
^b This is pattern matching and is similar to select case but not the same. It is usually used to deconstruct algebraic data types.
^c In languages of the Pascal family, the semicolon is not part of the statement. It is a separator between statements, not a terminator.
^d END-IF may be used instead of the period at the end.

Loop statements
while do while for i = first to last foreach
Ada[1] 
while condition loop
  statements
end loop
 
loop
  statements
  exit when not condition
end loop
 
for index in «reverse» [first .. last | discrete_type] loop
  statements
end loop
 
for item of «reverse» iterator loop
  statements
end loop

or

(for [all | some] [in | of] [first .. last | discrete_type | iterator] => predicate)[b]
ALGOL 68 
«for index» «from first» «by increment» «to last» «while condition» do statements od
 
for key «to upb list» do «typename val=list[key];» statements od
«while condition»
  do statements od
 
«while statements; condition»
  do statements od
 
«for index» «from first» «by increment» «to last» do statements od
APL 
:While condition
  statements
:EndWhile
 
:Repeat
  statements
:Until condition
 
:For var«s» :In list
  statements
:EndFor
 
:For var«s» :InEach list
  statements
:EndFor
C (C99) instructions can be a single statement or a block in the form of: { statements } 
while (condition) instructions
 
do instructions while (condition);
 
for («type» i = first; i <= last; i++) instructions
 N/A
Objective-C 
for (type item in set) instructions
C++ (STL) 
«std::»for_each(start, end, function)

Since C++11:

for (type item : set) instructions
C# 
foreach (type item in set) instructions
Java 
for (type item : set) instructions
JavaScript 
for (var i = first; i <= last; i++) instructions

Since EcmaScript 2015:[11]

for (var item of set) instructions
PHP 
foreach (range(first, last) as $i) instructions

or

for ($i = first; $i <= last; $i++) instructions
 
foreach (set as item) instructions

or

foreach (set as key => item) instructions
Windows PowerShell 
for ($i = first; $i -le last; $i++) instructions
 
foreach (item in set) instructions
D 
foreach (i; first ... last) instructions
 
foreach («type» item; set) instructions
Go 
for condition { instructions }
 
for i := first; i <= last; i++ { instructions }
 
for key, item := range set { instructions }
Swift 
while condition { instructions }
 2.x: 
repeat { instructions } while condition

1.x:

do { instructions } while condition
 
for i = first ... last { instructions }

or

for i = first ..< last+1 { instructions }

or

for var i = first; i <= last; i++ { instructions }
 
for item in set { instructions }
Perl 
while (condition) { instructions }

or

until (notcondition) { instructions }

do { instructions } while (condition) or

do { instructions } until (notcondition)
 
for«each» «$i» (first .. last) { instructions }

or

for ($i = first; $i <= last; $i++) { instructions }
 
for«each» «$item» (set) { instructions }
Raku 
while condition { instructions }

or

until notcondition { instructions }
 
repeat { instructions } while condition

or

repeat { instructions } until notcondition
 
for  first..last -> $i  { instructions }

or

loop ($i = first; $i <=last; $i++) { instructions }
 
for set« -> $item»  { instructions }
Ruby 
while condition
  instructions
end

or

until notcondition
  instructions
end
 
begin
  instructions
end while condition

or

begin
  instructions
end until notcondition
 
for i in first..last
  instructions
end

or

for i in first...last+1
  instructions
end

or

first.upto(last) { ||i|| instructions }
 
for item in set
  instructions
end

or

set.each { |item| instructions }
Bash shell 
while condition ;do
  instructions
done

or

until notcondition ;do
  instructions
done
 N/A 
for ((i = first; i <= last; ++i)) ; do
  instructions
done
 
for item in set ;do
  instructions
done
Scala 
while (condition) { instructions }
 
do { instructions } while (condition)
 
for (i <- first to last «by 1») { instructions }

or

first to last «by 1» foreach (i => { instructions })
 
for (item <- set) { instructions }

or

set foreach (item => { instructions })
Smalltalk 
conditionBlock whileTrue:
  loopBlock
 
loopBlock doWhile:
  conditionBlock
 
first to: last do:
  loopBlock
 
collection do:
  loopBlock
Common Lisp 
(loop
  while condition
  do
  instructions)

or

(do () (notcondition)
  instructions)
 
(loop
  do
  instructions
  while condition)
 
(loop
  for i from first to last «by 1»
  do
  instructions)

or

(dotimes (i N)
  instructions)

or

(do ((i first (1+ i))) ((>=i last))
  instructions)
 
(loop
  for item in list
  do
  instructions)

or

(loop
  for item across vector
  do
  instructions)

or

(dolist (item list)
  instructions)

or

(mapc function list)

or

(map 'type function sequence)
Scheme 
(do () (notcondition) instructions)

or

(let loop () (if condition (begin instructions (loop))))
 
(let loop () (instructions (if condition (loop))))
 
(do ((i first (+ i 1))) ((>= i last)) instructions)

or

(let loop ((i first)) (if (< i last) (begin instructions (loop (+ i 1)))))
 
(for-each (lambda (item) instructions) list)
ISLISP 
(while condition instructions)
 
(tagbody loop instructions (if condition (go loop))
 
(for ((i first (+ i 1))) ((>= i last)) instructions)
 
(mapc (lambda (item) instructions) list)
Pascal 
while condition do begin
  instructions
end
 
repeat
  instructions
until notcondition;
 
for i := first «step 1» to last do begin
  instructions
end;[a]
 
for item in set do instructions
Visual Basic 
Do While condition
  instructions
Loop

or

Do Until notcondition
  instructions
Loop

or

While condition
  instructions
Wend (Visual Basic .NET uses End While instead)
 
Do
  instructions
Loop While condition

or

Do
  instructions
Loop Until notcondition
 i must be declared beforehand. 
For i = first To last «Step 1»
  instructions
Next i
 
For Each item In set
  instructions
Next item
Visual Basic .NET 
For i« As type» = first To last« Step 1»
  instructions
Next« i»[a]
 
For Each item« As type» In set
  instructions
Next« item»
Xojo 
While condition
  instructions
Wend
 
Do Until notcondition
  instructions
Loop

or

Do
  instructions
Loop Until notcondition
Python 
while condition :
Tab ↹ instructions
«else:
Tab ↹ instructions»
 N/A Python 3.x: 
for i in range(first, last+1):
Tab ↹ instructions
«else:
Tab ↹ instructions»

Python 2.x:

for i in xrange(first, last+1):
Tab ↹ instructions
«else:
Tab ↹instructions»
 
for item in set:
Tab ↹ instructions
«else:
Tab ↹ instructions»
S-Lang 
while (condition) { instructions } «then optional-block»
 
do { instructions } while (condition) «then optional-block»
 
for (i = first; i <= last; i++) { instructions } «then optional-block»
 
foreach item(set) «using (what)» { instructions } «then optional-block»
Fortran 
DO WHILE (condition)
  instructions
ENDDO
 
DO
  instructions
   IF (condition) EXIT
ENDDO
 
DO I = first,last
  instructions
ENDDO
 N/A
Forth 
BEGIN « instructions » condition WHILE instructions REPEAT
 
BEGIN  instructions condition UNTIL
 
limit start DO instructions LOOP
 N/A
OCaml 
while condition do instructions done
 N/A 
for i = first to last do instructions done
 
Array.iter (fun item -> instructions) array

or

List.iter (fun item -> instructions) list
F# 
while condition do
Tab ↹ instructions
 N/A 
for i = first to last do
Tab ↹ instructions
 
for item in set do
Tab ↹ instructions

or

Seq.iter (fun item -> instructions) set
Standard ML 
while condition do ( instructions )
 N/A 
Array.app (fn item => instructions) array

or

app (fn item => instructions) list
Haskell (GHC) N/A 
Control.Monad.forM_ [first..last] (\i -> do instructions)
 
Control.Monad.forM_ list (\item -> do instructions)
Eiffel 
from
  setup
until
  condition
loop
  instructions
end
CoffeeScript 
while condition
  expression

or

expression while condition

or

while condition then expression

or

until condition
  expression

or

expression until condition

or

until expression then condition
 N/A 
for i in [first..last]
  expression

or

for i in [first..last] then expression

or

expression for i in [first..last]
 
for item in set
  expression

or

for item in set then expression

or

expression for item in set
COBOL 
PERFORM procedure-1 «THROUGH procedure-2» ««WITH» TEST BEFORE» UNTIL condition[c]

or

PERFORM ««WITH» TEST BEFORE» UNTIL condition
  expression
END-PERFORM
 
PERFORM procedure-1 «THROUGH procedure-2» «WITH» TEST AFTER UNTIL condition[c]

or

PERFORM «WITH» TEST AFTER UNTIL condition
  expression
END-PERFORM
 
PERFORM procedure-1 «THROUGH procedure-2» VARYING i FROM first BY increment UNTIL i > last[d]

or

PERFORM VARYING i FROM first BY increment UNTIL i > last
  expression
END-PERFORM[d]
 N/A

^a "step n" is used to change the loop interval. If "step" is omitted, then the loop interval is 1.

^b This implements the universal quantifier ("for all" or "∀") as well as the existential quantifier ("there exists" or "∃").

^c THRU may be used instead of THROUGH.

^d «IS» GREATER «THAN» may be used instead of >.

Exceptions
Further information: Exception handling syntax
throw handler assertion
Ada[1] raise exception_name «with string_expression» begin
statements
exception
when exception_list1 => statements;
when exception_list2 => statements;
...
«when others => statements;»
end[b]		 procedure | entry] with
Pre => boolean_expression
Post => boolean_expression

any_type with Type_Invariant => boolean_expression
APL «string_expression» ⎕SIGNAL number_expression :Trap number«s»_expression
statements
«:Case number«s»_expression
statements»
...
«:Else number«s»_expression
statements»
:EndTrap		 «string_expression» ⎕SIGNAL 98/⍨~condition
C (C99) longjmp(state, exception); switch (setjmp(state)) { case 0: instructions break; case exception: instructions ... } assert(condition);
C++ throw exception; try { instructions } catch «(exception)» { instructions } ...
C# try { instructions } catch «(exception« name»)» { instructions } ... «finally { instructions }» System.Diagnostics.Debug.Assert(condition);or

System.Diagnostics.Trace.Assert(condition);

Java try { instructions } catch (exception) { instructions } ... «finally { instructions }» assert condition «: description»;
JavaScript try { instructions } catch (exception) { instructions } «finally { instructions }» ?
D try { instructions } catch (exception) { instructions } ... «finally { instructions }» assert(condition);
PHP try { instructions } catch (exception) { instructions } ... «finally { instructions }» assert(condition);
S-Lang try { instructions } catch «exception» { instructions } ... «finally { instructions }» ?
Windows PowerShell trap «[exception]» { instructions } ... instructions or try { instructions } catch «[exception]» { instructions } ... «finally { instructions }» [Debug]::Assert(condition)
Objective-C @throw exception; @try { instructions } @catch (exception) { instructions } ... «@finally { instructions }» NSAssert(condition, description);
Swift throw exception (2.x) do { try expression ... instructions } catch exception { instructions } ... (2.x) assert(condition«, description»)
Perl die exception; eval { instructions }; if ($@) { instructions } ?
Raku try { instructions CATCH { when exception { instructions } ...}} ?
Ruby raise exception begin
instructions
rescue exception
instructions
...
«else
instructions»
«ensure
instructions»
end
Smalltalk exception raise instructionBlock on: exception do: handlerBlock assert: conditionBlock
Common Lisp (error "exception") or
(error
type
arguments)
or
(error (make-condition
type
arguments))
 (handler-case
(progn instructions)
(exception instructions)
...)
or
(handler-bind
(condition
(lambda
instructions
«invoke-restart restart args»))
...)[a]
 (assert condition) or
(assert condition
«(place)
«error»»)
or
(check-type var type)
Scheme (R6RS) (raise exception) (guard (con (condition instructions) ...) instructions) ?
ISLISP (error "error-string" objects) or
(signal-condition condition continuable)		 (with-handler
handler form*
)		 ?
Pascal raise Exception.Create() try Except on E: exception do begin instructions end; end; ?
Visual Basic Err.Raise ERRORNUMBER With New Try: On Error Resume Next
OneInstruction
.Catch: On Error GoTo 0: Select Case .Number
Case SOME_ERRORNUMBER
instructions
End Select: End With 
'*** Try class ***
Private 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() As String
    Description = mstrDescription
End Property
[12]		 Debug.Assert condition
Visual Basic .NET Throw exceptionor

Error errorcode

 Try
instructions
Catch« name As exception»« When condition»
instructions
...
«Finally
instructions»
End Try		 System.Diagnostics.Debug.Assert(condition)or

System.Diagnostics.Trace.Assert(condition)

Xojo Raise exception Try
instructions
Catch «exception»
instructions
...
«Finally
instructions»
End Try		 N/A
Python raise exception try:
Tab ↹ instructions
except «exception»:
Tab ↹ instructions
...
«else:
Tab ↹ instructions»
«finally:
Tab ↹ instructions»		 assert condition
Fortran N/A
Forth code THROW xt CATCH ( code or 0 ) N/A
OCaml raise exception try expression with pattern -> expression ... assert condition
F# try expression with pattern -> expression ...
or
try expression finally expression
Standard ML raise exception «arg» expression handle pattern => expression ...
Haskell (GHC) throw exception
or
throwError expression		 catch tryExpression catchExpression
or
catchError tryExpression catchExpression		 assert condition expression
COBOL RAISE «EXCEPTION» exception USE «AFTER» EXCEPTION OBJECT class-name. or
USE «AFTER» EO class-name. or
USE «AFTER» EXCEPTION CONDITION exception-name «FILE file-name». or
USE «AFTER» EC exception-name «FILE file-name».		 N/A

^a Common Lisp allows with-simple-restart, restart-case and restart-bind to define restarts for use with invoke-restart. Unhandled conditions may cause the implementation to show a restarts menu to the user before unwinding the stack.

^b Uncaught exceptions are propagated to the innermost dynamically enclosing execution. Exceptions are not propagated across tasks (unless these tasks are currently synchronised in a rendezvous).

Other control flow statements
exit block(break) continue label branch (goto) return value from generator
Ada[1] exit «loop_name» «when condition» N/A label: goto label N/A
ALGOL 68 value exit; ... do statements; skip exit; label: statements od label: ... go to label; ...
goto label; ...
label; ...		 yield(value)

(Callback)[13]

APL :Leave :Continue label: →label
or
:GoTo label		 N/A
C (C99) break; continue; label: goto label; N/A
Objective-C
C++ (STL)
D
C# yield return value;
Java break «label»; continue «label»; N/A
JavaScript yield value«;»
PHP break «levels»; continue «levels»; goto label; yield «key =>» value;
Perl last «label»; next «label»;
Raku
Go break «label» continue «label» goto label
Swift break «label» continue «label» N/A
Bash shell break «levels» continue «levels» N/A N/A N/A
Common Lisp (return) or
(return-from block) or
(loop-finish)		 (tagbody tag
...
tag
...)		 (go tag)
Scheme
ISLISP (return-from block) (tagbody tag
...
tag
...)		 (go tag)
Pascal(ISO) N/A label:[a] goto label; N/A
Pascal(FPC) break; continue;
Visual Basic Exit blockAlternatively, for methods,

Return

 N/A label: GoTo label
Xojo Continue block
Visual Basic .NET Yield value
Python break continue N/A yield value
RPG IV LEAVE; ITER;
S-Lang break; continue;
Fortran EXIT CYCLE label[b] GOTO label N/A
Ruby break next
Windows PowerShell break «label» continue
OCaml N/A
F#
Standard ML
Haskell (GHC)
COBOL EXIT PERFORM or EXIT PARAGRAPH or EXIT SECTION or EXIT. EXIT PERFORM CYCLE label «SECTION». GO TO label N/A
Ya break «from where»; f.e.

break for switch;

 continue «to where»; f.e.

continue for switch;

 :label goto :label; N/A

^a Pascal has declaration blocks. See functions.
^b label must be a number between 1 and 99999.

Functions

See reflection for calling and declaring functions by strings.

calling a function basic/void function value-returning function required main function
Ada[1] foo «(parameters)» procedure foo «(parameters)» is begin statements end foo function foo «(parameters)» return type is begin statements end foo N/A
ALGOL 68 foo«(parameters)»; proc foo = «(parameters)» void: ( instructions ); proc foo = «(parameters)» rettype: ( instructions ...; retvalue ); N/A
APL «parameters» foo parameters foo←{ statements } foo←{ statements } N/A
C (C99) foo(«parameters») void foo(«parameters») { instructions } type foo(«parameters») { instructions ... return value; } «global declarations»
int main(«int argc, char *argv[]») {
instructions
}
Objective-C
C++ (STL)
Java public static void main(String[] args) { instructions } or
public static void main(String... args) { instructions }
D int main(«char[][] args») { instructions} or
int main(«string[] args») { instructions} or
void main(«char[][] args») { instructions} or
void main(«string[] args») { instructions}
C# Same as above; alternatively, if only one statement:

void foo(«parameters») => statement;

 Same as above; alternatively, if simple enough to be an expression:

void foo(«parameters») => expression;

 static void Main(«string[] args») method_body

May instead return int.

(starting with C# 7.1:) May return Task or Task<int>, and if so, may be async.

JavaScript function foo(«parameters») { instructions } or
var foo = function («parameters») {instructions } or
var foo = new Function («"parameter", ... ,"last parameter"» "instructions");		 function foo(«parameters») { instructions ... return value; } N/A
Go func foo(«parameters») { instructions } func foo(«parameters») type { instructions ... return value } func main() { instructions }
Swift func foo(«parameters») { instructions } func foo(«parameters») -> type { instructions ... return value } N/A
Common Lisp (foo «parameters») (defun foo («parameters»)
instructions)
or
(setf (symbol-function 'symbol)
function)
 (defun foo («parameters»)
...
value)
 N/A
Scheme (define (foo parameters) instructions) or
(define foo (lambda (parameters) instructions))		 (define (foo parameters) instructions... return_value) or
(define foo (lambda (parameters) instructions... return_value))
ISLISP (defun foo («parameters»)
instructions)
 (defun foo («parameters»)
...
value)
Pascal foo«(parameters)» procedure foo«(parameters)»; «forward;»[a]
«label
label declarations»
«const
constant declarations»
«type
type declarations»
«var
variable declarations»
«local function declarations»
begin
instructions
end;		 function foo«(parameters)»: type; «forward;»[a]
«label
label declarations»
«const
constant declarations»
«type
type declarations»
«var
variable declarations»
«local function declarations»
begin
instructions;
foo := value
end;		 program name;
«label
label declarations»
«const
constant declarations»
«type
type declarations»
«var
variable declarations»
«function declarations»
begin
instructions
end.
Visual Basic Foo(«parameters») Sub Foo«(parameters)»
instructions
End Sub		 Function Foo«(parameters)»« As type»
instructions
Foo = value
End Function		 Sub Main()
instructions
End Sub
Visual Basic .NET Same as above; alternatively: Function Foo«(parameters)»« As type»
instructions
Return value
End Function


The As clause is not required if Option Strict is off. A type character may be used instead of the As clause.

If control exits the function without a return value having been explicitly specified, the function returns the default value for the return type.

 Sub Main(««ByVal »args() As String»)
instructions
End Subor Function Main(««ByVal »args() As String») As Integer
instructions
End Function
Xojo
Python foo(«parameters») def foo(«parameters»):
Tab ↹ instructions 		def foo(«parameters»):
Tab ↹ instructions
Tab ↹ return value		 N/A
S-Lang foo(«parameters» «;qualifiers») define foo («parameters») { instructions } define foo («parameters») { instructions ... return value; } public define slsh_main () { instructions }
Fortran foo («arguments»)
CALL sub_foo («arguments»)[c]		 SUBROUTINE sub_foo («arguments»)
instructions
END SUBROUTINE[c]		 type FUNCTION foo («arguments»)
instructions
...
foo = value
END FUNCTION[c]		 PROGRAM main
instructions
END PROGRAM
Forth «parameters» FOO : FOO « stack effect comment: ( before -- ) »
instructions
;		 : FOO « stack effect comment: ( before -- after ) »
instructions
;		 N/A
PHP foo(«parameters») function foo(«parameters») { instructions } function foo(«parameters») { instructions ... return value; } N/A
Perl foo(«parameters») or
&foo«(parameters)»		 sub foo { «my (parameters) = @_;» instructions } sub foo { «my (parameters) = @_;» instructions... «return» value; }
Raku foo(«parameters») or
&foo«(parameters)»		 «multi »sub foo(parameters) { instructions } «our «type» »«multi »sub foo(parameters) { instructions... «return» value; }
Ruby foo«(parameters)» def foo«(parameters)»
instructions
end		 def foo«(parameters)»
instructions
«return» value
end
Rust foo(«parameters») fn foo(«parameters») { instructions } fn foo(«parameters») -> type { instructions } fn main() { instructions }
Scala foo«(parameters)» def foo«(parameters)»«: Unit =» { instructions } def foo«(parameters)»«: type» = { instructions ... «return» value } def main(args: Array[String]) { instructions }
Windows PowerShell foo «parameters» function foo { instructions };
or
function foo { «param(parameters)» instructions }		 function foo «(parameters)» { instructions … return value }; or
function foo { «param(parameters)» instructions … return value }		 N/A
Bash shell foo «parameters»

function foo {
    instructions
}
or
foo () {
    instructions
}

function foo {
    instructions
    return «exit_code»
}
or
foo () {
    instructions
    return «exit_code»
}

  • parameters
    • $n ($1, $2, $3, ...)
    • $@ (all parameters)
    • $# (the number of parameters)
    • $0 (this function name)
OCaml foo parameters let «rec» foo parameters = instructions let «rec» foo parameters = instructions... return_value
F# [<EntryPoint>] let main args = instructions
Standard ML fun foo parameters = ( instructions ) fun foo parameters = ( instructions... return_value )
Haskell foo parameters = do
Tab ↹ instructions		 foo parameters = return_value
or
foo parameters = do
Tab ↹ instructions
Tab ↹ return value		 «main :: IO ()»
main = do instructions
Eiffel foo («parameters») foo («parameters»)
require
preconditions
do
instructions
ensure
postconditions
end
 foo («parameters»): type
require
preconditions
do
instructions
Result := value
ensure
postconditions
end
 [b]
CoffeeScript foo() foo = -> foo = -> value N/A
foo parameters foo = () -> foo = ( parameters ) -> value
COBOL CALL "foo" «USING parameters»
«exception-handling»
«END-CALL»[d]		 «IDENTIFICATION DIVISION.»

PROGRAM-ID. foo.
«other divisions...»
PROCEDURE DIVISION «USING parameters».

instructions.
 «IDENTIFICATION DIVISION.»

PROGRAM-ID/FUNCTION-ID. foo.
«other divisions...»
DATA DIVISION.
«other sections...»
LINKAGE SECTION.
«parameter definitions...»
variable-to-return definition
«other sections...»
PROCEDURE DIVISION «USING parameters» RETURNING variable-to-return.

instructions.
 N/A
«FUNCTION» foo«(«parameters»)» N/A

^a Pascal requires "forward;" for forward declarations.
^b Eiffel allows the specification of an application's root class and feature.
^c In Fortran, function/subroutine parameters are called arguments (since PARAMETER is a language keyword); the CALL keyword is required for subroutines.
^d Instead of using "foo", a string variable may be used instead containing the same value.

Type conversions

Where string is a signed decimal number:

string to integer string to long integer string to floating point integer to string floating point to string
Ada[1] Integer'Value (string_expression) Long_Integer'Value (string_expression) Float'Value (string_expression) Integer'Image (integer_expression) Float'Image (float_expression)
ALGOL 68 with general, and then specific formats With prior declarations and association of: string buf := "12345678.9012e34 "; file proxy; associate(proxy, buf);
get(proxy, ivar);
 
get(proxy, livar);
 
get(proxy, rvar);
 
put(proxy, ival);
 
put(proxy, rval);
getf(proxy, ($g$, ivar));
or 
getf(proxy, ($dddd$, ivar));
 
getf(proxy, ($g$, livar));
or 
getf(proxy, ($8d$, livar));
 
getf(proxy, ($g$, rvar));
or 
getf(proxy, ($8d.4dE2d$, rvar));
 
putf(proxy, ($g$, ival));
or 
putf(proxy, ($4d$, ival));
 
putf(proxy, ($g(width, places, exp)$, rval));
or 
putf(proxy, ($8d.4dE2d$, rval));
APL ⍎string_expression ⍎string_expression ⍎string_expression ⍕integer_expression ⍕float_expression
C (C99) integer = atoi(string); long = atol(string); float = atof(string); sprintf(string, "%i", integer); sprintf(string, "%f", float);
Objective-C integer = [string intValue]; long = [string longLongValue]; float = [string doubleValue]; string = [NSString stringWithFormat:@"%i", integer]; string = [NSString stringWithFormat:@"%f", float];
C++ (STL) «std::»istringstream(string) >> number; «std::»ostringstream o; o << number; string = o.str();
C++11 integer = «std::»stoi(string); long = «std::»stol(string); float = «std::»stof(string); double = «std::»stod(string); string = «std::»to_string(number);
C# integer = int.Parse(string); long = long.Parse(string); float = float.Parse(string); double = double.Parse(string); string = number.ToString();
D integer = std.conv.to!int(string) long = std.conv.to!long(string) float = std.conv.to!float(string) double = std.conv.to!double(string) string = std.conv.to!string(number)
Java integer = Integer.parseInt(string); long = Long.parseLong(string); float = Float.parseFloat(string);
double = Double.parseDouble(string);		 string = Integer.toString(integer); string = String.valueOf(integer); string = Float.toString(float); string = Double.toString(double);
JavaScript[a] integer = parseInt(string); float = parseFloat(string); float = new Number (string);

float = Number (string);

float = +string;

 string = number.toString ();
string = String (number);
string = number+"";
string = `${number}`
Go integer, error = strconv.Atoi(string)
integer, error = strconv.ParseInt(string, 10, 0)		 long, error = strconv.ParseInt(string, 10, 64) float, error = strconv.ParseFloat(string, 64) string = strconv.Itoa(integer) string = strconv.FormatInt(integer, 10)

string = fmt.Sprint(integer)

 string = strconv.FormatFloat(float) string = fmt.Sprint(float)
Rust[d] string.parse::<i32>()
i32::from_str(string)		 string.parse::<i64>()
i64::from_str(string)		 string.parse::<f64>()
f64::from_str(string)		 integer.to_string() float.to_string()
Common Lisp (setf integer (parse-integer string)) (setf float (read-from-string string)) (setf string (princ-to-string number))
Scheme (define number (string->number string)) (define string (number->string number))
ISLISP (setf integer (convert string <integer>)) (setf float (convert string <float>)) (setf string (convert number <string>))
Pascal integer := StrToInt(string); float := StrToFloat(string); string := IntToStr(integer); string := FloatToStr(float);
Visual Basic integer = CInt(string) long = CLng(string) float = CSng(string)
double = CDbl(string)		 string = CStr(number)
Visual Basic .NET

(can use both VB syntax above

and .NET methods shown right)

 integer = Integer.Parse(string) long = Long.Parse(string) float = Single.Parse(string) double = Double.Parse(string) string = number.ToString()
Xojo integer = Val(string) long = Val(string) double = Val(string) double = CDbl(string) string = CStr(number) or string = Str(number)
Python integer = int(string) long = long(string) float = float(string) string = str(number)
S-Lang integer = atoi(string); long = atol(string); float = atof(string); string = string(number);
Fortran READ(string,format) number WRITE(string,format) number
PHP integer = intval(string); or integer = (int)string; float = floatval(string); float = (float)string; string = "$number"; or string = strval(number); or

string = (string)number;

Perl[b] number = 0 + string; string = "number";
Raku number = +string; string = ~number;
Ruby integer = string.to_i or integer = Integer(string) float = string.to_f float = Float(string) string = number.to_s
Scala integer = string.toInt long = string.toLong float = string.toFloat double = string.toDouble string = number.toString
Smalltalk integer := Integer readFrom: string float := Float readFrom: string string := number asString
Windows PowerShell integer = [int]string long = [long]string float = [float]string string = [string]number; or
string = "number"; or
string = (number).ToString()
OCaml let integer = int_of_string string let float = float_of_string string let string = string_of_int integer let string = string_of_float float
F# let integer = int string let integer = int64 string let float = float string let string = string number
Standard ML val integer = Int.fromString string val float = Real.fromString string val string = Int.toString integer val string = Real.toString float
Haskell (GHC) number = read string string = show number
COBOL MOVE «FUNCTION» NUMVAL(string)[c] TO number MOVE number TO numeric-edited

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

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


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

Reading command-line arguments
Argument values Argument counts Program name / Script name
Ada[1] Argument (n) Argument_Count Command_Name
C (C99) argv[n] argc first argument
Objective-C
C++
C# args[n] args.Length Assembly.GetEntryAssembly().Location;
Java args.length
D first argument
JavaScript
Windows Script Host implementation		 WScript.Arguments(n) WScript.Arguments.length WScript.ScriptName or WScript.ScriptFullName
Go os.Args[n] len(os.Args) first argument
Rust[a] std::env::args().nth(n)
std::env::args_os().nth(n)		 std::env::args().count()
std::env::args_os().count()		 std::env::args().next()
std::env::args_os().next()
Swift Process.arguments[n] or
Process.unsafeArgv[n]		 Process.arguments.count or
Process.argc		 first argument
Common Lisp ? ? ?
Scheme (R6RS) (list-ref (command-line) n) (length (command-line)) first argument
ISLISP N/A N/A N/A
Pascal ParamStr(n) ParamCount first argument
Visual Basic Command[b] N/A App.Path
Visual Basic .NET CmdArgs(n) CmdArgs.Length [Assembly].GetEntryAssembly().Location
Xojo System.CommandLine (string parsing) Application.ExecutableFile.Name
Python sys.argv[n] len(sys.argv) first argument
S-Lang __argv[n] __argc first argument
Fortran DO i = 1,argc
CALL GET_COMMAND_ARGUMENT (i,argv(i))
ENDDO		 argc = COMMAND_ARGUMENT_COUNT () CALL GET_COMMAND_ARGUMENT (0,progname)
PHP $argv[n] $argc first argument
Bash shell $n ($1, $2, $3, ...)
$@ (all arguments)		 $# $0
Perl $ARGV[n] scalar(@ARGV) $0
Raku @*ARGS[n] @*ARGS.elems $PROGRAM_NAME
Ruby ARGV[n] ARGV.size $0
Windows PowerShell $args[n] $args.Length $MyInvocation.MyCommand.Name
OCaml Sys.argv.(n) Array.length Sys.argv first argument
F# args.[n] args.Length Assembly.GetEntryAssembly().Location
Standard ML List.nth (CommandLine.arguments (), n) length (CommandLine.arguments ()) CommandLine.name ()
Haskell (GHC) do { args <- System.getArgs; return length args !! n }<nowiki /> do { args <- System.getArgs; return length args }<nowiki /> System.getProgName
COBOL [c] N/A
  • ^a In Rust, std::env::args and std::env::args_os return iterators, std::env::Args and std::env::ArgsOs respectively. Args converts each argument to a String and it panics if it reaches an argument that cannot be converted to UTF-8. ArgsOs returns a non-lossy representation of the raw strings from the operating system (std::ffi::OsString), which can be invalid UTF-8.
  • ^b In Visual Basic, command-line arguments are not separated. Separating them requires a split function Split(string).
  • ^c The COBOL standard includes no means to access command-line arguments, but common compiler extensions to access them include defining parameters for the main program or using ACCEPT statements.

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

output=$(command)

 program arg1 arg2 …

^a Fortran 2008 or newer.[16]

References
  1. Ada Reference Manual – Language and Standard Libraries; ISO/IEC 8652:201x (E), "Reference Manual" (PDF). Archived from the original (PDF) on 2011-04-27. Retrieved 2013-07-19.
  2. "Common Lisp HyperSpec (TM)". lispworks.com. Retrieved 30 January 2017.
  3. "www.islisp.info: Specification". islisp.info. Archived from the original on 22 January 2016. Retrieved 30 January 2017.
  4. "selected_int_kind in Fortran Wiki". fortranwiki.org. Retrieved 30 January 2017.
  5. "Erlang -- Types and Function Specifications". erlang.org. Retrieved 30 January 2017.
  6. "Erlang -- Advanced". erlang.org. Retrieved 30 January 2017.
  7. 8.5 The Number Type
  8. "selected_real_kind in Fortran Wiki". fortranwiki.org. Retrieved 30 January 2017.
  9. "The GNU C Library: Complex Numbers". gnu.org. Retrieved 30 January 2017.
  10. "Grammar vb". Visual Basic Language Specification. 2016-06-17. Archived from the original on 2019-08-29. Retrieved 2019-08-29.
  11. "for...of". mozilla.org. Retrieved 30 January 2017.
  12. "Try-Catch for VB". google.com. Retrieved 30 January 2017.
  13. "Prime decomposition – Rosetta Code". rosettacode.org. Retrieved 30 January 2017.
  14. "iso_fortran_env in Fortran Wiki". fortranwiki.org. Retrieved 30 January 2017.
  15. "Execute a system command – Rosetta Code". rosettacode.org. Retrieved 30 January 2017.
  16. "EXECUTE_COMMAND_LINE – The GNU Fortran Compiler". gnu.org. Retrieved 30 January 2017.
This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.