| Perbandingan -- programming languages (basic instructions)Perbandingan -- programming languages is a common topic of discussion among software engineers. Basic instructions of several programming languages are compared here.
Conventions of this articleThe bold is the literal code. The non-bold is interpreted by the reader. Statements in guillemets (« … ») are optional. Tab ↹ indicates a necessary indent.
Type identifiers | 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 |
---|
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 | int | unsigned int | 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] | C++ (C++11 variable-width) | Objective-C | signed char | unsigned char | short[c] | unsigned short[c] | long[c] | unsigned long[c] | long long[c] | unsigned long long[c] | int or NSInteger | unsigned int or NSUInteger | C# | sbyte | byte | short | ushort | int | uint | long | ulong | N/A | System.Numerics.BigInteger (.NET 4.0) | Java | byte | N/A | char[b] | N/A | N/A | java.math.BigInteger | Go | int8 | uint8 or byte | int16 | uint16 | int32 | uint32 | int64 | uint64 | int | uint | big.Int | D | byte | ubyte | short | ushort | int | uint | long | ulong | N/A | N/A | BigInt | Common Lisp[1] | | | | | | | | | | | bignum | Scheme | | | | | | | | | | | | ISLISP[2] | | | | | | | | | | | 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) | 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 | N/A | N/A | N/A | [e] | Perl 5 | N/A[d] | N/A[d] | N/A[d] | N/A[d] | N/A[d] | Math::BigInt | Perl 6 | int8 | uint8 | int16 | uint16 | int32 | uint32 | int64 | uint64 | Int | N/A | Ruby | N/A | N/A | N/A | N/A | Fixnum | N/A | Bignum | 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 |
^a The standard constants int shorts and int lengths can be used to determine how many shorts and longs 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 often 64 bits wide). C99 and C++11[citation needed] also define the "[u]intN_t" exact-width types in the stdint.h header. See C syntax#Integral types for more information. ^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[3] intrinsic function. ^g ALGOL 68G's run time option --precision "number" can set precision for long long int's 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 required 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. | Single precision | Double precision | Processor dependent |
---|
ALGOL 68 | real[a] | long real[a] | short real etc. & long long real etc.[d] | C | float[b] | double | N/A[b] | Objective-C | C++ (STL) | C# | float | N/A | Java | Go | float32 | float64 | D | float | double | real | Common Lisp | | | | Scheme | | | | ISLISP | | | | Pascal (Free Pascal) | single | double | real | Visual Basic | Single | Double | N/A | Visual Basic .NET | Python | N/A | float | | JavaScript | Number[4] | N/A | S-Lang | | | | Fortran | REAL(KIND = n)[c] | | PHP | | float | | Perl | | | | Perl 6 | num32 | num64 | Num | Ruby | N/A | Float | N/A | 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[e] | FLOAT-SHORT | FLOAT-LONG | |
^a The standard constants real shorts and real lengths can be used to determine how many shorts and longs 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[5] intrinsic function. ^d ALGOL 68G's run time option --precision "number" can set precision for long long real's 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 COBOL also supports FLOAT-EXTENDED. The types FLOAT-BINARY-7, FLOAT-BINARY-16 and FLOAT-BINARY-34, specify IEEE-754 binary floating point variables, and FLOAT-DECIMAL-16 and FLOAT-DECIMAL-34 specify IEEE decimal floating point variables. | Integer | Single precision | Double precision | Half and Quadruple precision etc. |
---|
ALGOL 68 | N/A | compl | long compl etc. | short compl etc. & long long compl etc. | C (C99) [6] | 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 | | | | Scheme | | | | 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 | | Perl 6 | | 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 | 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 |
^a The value of "n" is provided by the SELECTED_REAL_KIND[5] intrinsic function. Other variable types | Text | Boolean | Enumeration | Object/Universal |
---|
Character | String[a] |
---|
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, item2, ... } | object | Java | String | boolean | Object | Go | rune | string | bool | const ( item1 = iota item2 ... ) | interface{} | D | char | string | bool | enum name {item1, item2, ... } | std.variant.Variant | Common Lisp | | | | | | 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 item2 ... End Enum | Variant | Visual Basic .NET | Char | Object | Python | N/A[d] | str | bool | | 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 | | object | Perl | N/A[d] | | | | | Perl 6 | Char | Str | Bool | enum name <item1 item2 ...> or enum name <<:item1(value) :item2(value) ...>> | Mu | Ruby | N/A[d] | String | Object[c] | | Object | Windows PowerShell | | | | | | OCaml | char | string | bool | N/A[e] | N/A | F# | type name = item1 = value | 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 |
^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[3] intrinsic function. Derived types | fixed size array | dynamic size array |
---|
one-dimensional array | multi-dimensional array | one-dimensional array | multi-dimensional array |
---|
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) | [a] | [a] | | | 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 | vector.Vector | | Objective-C | NSArray | | NSMutableArray | | JavaScript | N/A | N/A | Array[d] | Common Lisp | | | | | 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 | | | | | Visual Basic .NET | | | System.Collections.ArrayList or System.Collections.Generic.List(Of type) | | Python | | | list | | S-Lang | | | | | Fortran | type :: name(size) | type :: name(size1, size2,...) | type, ALLOCATABLE :: name(:) | type, ALLOCATABLE :: name(:,:,...) | PHP | | | array | | Perl | | | | | Perl 6 | | | Array[type] or Array of type | | Ruby | | | Array | | 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) | | | | |
^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. Also C's arrays can not be described in this format. See C syntax#Arrays. ^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. Other types | Simple composite types | Algebraic data types | Unions |
---|
Records | Tuple expression |
---|
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;...} | | | 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 ... } | | | | Common Lisp | | (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 | | | | 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 | Perl 6 | N/A[a] | | | Ruby | OpenStruct.new({:name => value}) | | | 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, ... ) | datatype name = Foo «of type» | Bar «of type» | ... | Haskell | data Name = Constr {name :: type,...} | data Name = Foo «types» | Bar «types» | ... |
^a Only classes are supported. ^b struct s 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 |
---|
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 name «= initial_value»; or var name = value; | const type name = value; or readonly type 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»; | const name = value; | Go | var name type «= initial_value» or name := initial_value | const name «type» = initial_value | type synonym type | Common Lisp | (defparameter name initial_value) or (defvar name initial_value) or (setf (symbol-value 'symbol) 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 | Const name As type = value | | Visual Basic .NET | Dim name As type«= initial_value» | Imports synonym = type | Python | name = initial_value | N/A | synonym = type[b] | 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; | Perl 6 | «my «type»» $name «= initial_value»;[c] | «my «type»» constant name = value; | ::synonym ::= type | Ruby | name = initial_value | Name = value | synonym = type[b] | Windows PowerShell | «[type]» $name = initial_value | | | 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 | |
^a Pascal has declaration blocks. See Perbandingan -- programming languages (basic instructions)#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. | if | else if | select case | conditional expression |
---|
Ada | if condition then statements «elsestatements» end if | if condition then statements elsif condition thenstatements ... «elsestatements» end if | case expression is when choice1 => statements ... «when others => statements» end case | | Modula-2 | case expression is caseLabelList : statements | ... «else statements» end | | Seed7 | case expression of when set1 : statements ... «otherwise: statements» end case | | ALGOL 68 & "brief form" | 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 ) | ( condition | statements «| statements» ) | ( condition | statements |: condition | statements ) | ( variable | statements,... «| statements» ) | C (C99) | if (condition) {instructions} «else {instructions}» | if (condition) {instructions} else if (condition) {instructions} ... «else {instructions}» | switch (variable) { case case1: instructions «break;» ... «default: instructions» } | condition ? valueIfTrue : valueIfFalse | Objective-C | C++ (STL) | D | Java | JavaScript | PHP | C# | switch (variable) { case case1: instructions; «jump statement;» ... «default: instructions; «jump statement;»» } | Windows PowerShell | 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» } | | 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 | Perl 6 | 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 «elseinstructions» | if condition instructions elsif conditioninstructions ... «elseinstructions» end | case variable when case1
instructions ... «elseinstructions» end | condition ? valueIfTrue : valueIfFalse | Smalltalk | condition ifTrue: trueBlock «ifFalse:falseBlock» end | | | condition ifTrue: trueBlockifFalse: 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 condition valueIfTrue valueIfFalse) | Scheme | (when conditioninstructions) or (if condition (begin instructions) «(begin instructions)») | (cond (condition1 instructions) (condition2 instructions) ... «(else instructions)») | (case (variable) ((case1) instructions) ((case2) instructions) ... «(else instructions)») | 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 begininstructions end»[c] | if condition then begin instructions end else if condition then begininstructions end ... «else begininstructions end»[c] | case variable of case1: instructions ... «else: instructions» end[c] | Visual Basic | If condition Then instructions «Elseinstructions» End If | If condition Then instructions ElseIf condition Theninstructions ... «Elseinstructions» End If | Select Case variable Case case1instructions ... «Case Elseinstructions» End Select | IIf(condition, valueIfTrue, valueIfFalse) | Visual Basic .NET | If(condition, valueIfTrue, valueIfFalse) | Python [a] | if condition : Tab ↹ instructions «else: Tab ↹ instructions» | if condition : Tab ↹ instructions elif condition : Tab ↹ instructions ... «else: Tab ↹ instructions» | N/A | valueIfTrue if condition else valueIfFalse (Python 2.5+) | 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 ELSEinstructions ENDIF | IF (condition) THEN instructions ELSEIF (condition) THENinstructions ... ELSEinstructions ENDIF | SELECT CASE(variable)CASE (case1 )instructions ... CASE DEFAULTinstructions 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 withpattern1 -> expression | pattern2 -> expression ... « | _ -> expression» [b] | if condition then valueIfTrue else valueIfFalse | F# | if condition then Tab ↹ instructions «else Tab ↹ instructions» | if condition then Tab ↹ instructions elif condition then Tab ↹ instructions ... «else Tab ↹ instructions» | Standard ML | if condition then «(»instructions «)» else «(» instructions «)» | if condition then «(»instructions «)» else if condition then «(» instructions «)» ... else «(» instructions «)» | case value ofpattern1 => 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] | | 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 in 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. | while | do while | for i = first to last | foreach |
---|
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 | C (C99) | 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) (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 } | for (var index in set) { instructions } or for each (var item in set) { instructions } (JS 1.6+) | PHP | foreach (range(first, last-1) 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 using item } | 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 } | Perl | while (condition) { instructions } or until (notcondition) { instructions } | do { instructions } while (condition) or do { instructions } until (notcondition) | for«each» «$i» (0 .. N-1) { instructions } or for ($i = first; $i <= last; $i++) { instructions } | for«each» «$item» (set) { instructions } | Perl 6 | 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 notconditioninstructions end | begin instructions end while condition or begininstructions end until notcondition | for i in first...last instructions end or first.upto(last-1) { |i| instructions } | for item in set instructions end or set.each { |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 set do instructions) or (dolist (item set)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] | N/A | Visual Basic | Do While condition instructions Loop or Do Until notconditioninstructions Loop | Do instructions Loop While condition or Doinstructions Loop Until notcondition | 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 | Python | while condition : Tab ↹ instructions «else: Tab ↹ instructions» | N/A | for i in range(first, last): 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-1 do instructions done | Array.iter (fun item -> instructions) array List.iter (fun item -> instructions) list | F# | while condition do Tab ↹ instructions | N/A | for i = first to last-1 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 app (fn item => instructions) list | Haskell (GHC) | N/A | Control.Monad.forM_ [0..N-1] (\i -> do instructions) | Control.Monad.forM_ list (\item -> do instructions) | Eiffel | from setup untilcondition loopinstructions end |
^a "step n" is used to change the loop interval. If "step" is omitted, then the loop interval is 1. | throw | handler | assertion |
---|
C (C99) | longjmp(state, exception); | switch (setjmp(state)) { case 0: instructions break; case exception: instructions ... } | assert(condition); | C++ (STL) | throw exception; | try { instructions } catch «(exception)» { instructions } ... | C# | try { instructions } catch «(exception)» { instructions } ... «finally { instructions }» | Debug.Assert(condition); | Java | try { instructions } catch (exception) { instructions } ... «finally { instructions }» | assert condition; | JavaScript | try { instructions } catch (exception) { instructions } «finally { instructions }» | ? | D | try { instructions } catch (exception) { instructions } ... «finally { instructions }» | assert(condition); | PHP | try { instructions } catch (exception) { 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); | Perl | die exception; | eval { instructions }; if ($@) { instructions } | ? | Perl 6 | try { instructions CATCH { when exception { instructions } ...}} | ? | Ruby | raise exception | begin instructions rescue exceptioninstructions ... «elseinstructions» «ensureinstructions» end | | Smalltalk | exception raise | instructionBlock on: exception do: handlerBlock | assert: conditionBlock | Common Lisp | (error "exception") or (error (make-conditiontype 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 .NumberCase 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 LongNumber = mlngNumber End Property Public Property Get Description() As StringDescription = mstrDescription End Property
https://sites.google.com/site/truetry forvisualbasic/ | Debug.Assert condition | Visual Basic .NET | Throw exception | Try instructions Catch «exception» «When condition»instructions ... «Finallyinstructions» End Try | Debug.Assert(condition) | 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 |
^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. Other control flow statements | exit block(break) | continue | label | branch (goto) | return value from generator |
---|
ALGOL 68 | value exit; ... | do statements; skip exit; label: statements od | label: ... | go to label; ...
goto label; ... label; ... | yield(value) (Callback - example) | 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; | | Perl | last «label»; | next «label»; | | Perl 6 | | Go | break «label» | continue «label» | goto label | | Common Lisp | (return) or (return-from block) or (loop-finish) | | (tagbody tag | (go tag) | | Scheme | | | | | | ISLISP | (return-from block) | | (tagbody tag | (go tag) | | Pascal(ISO) | N/A | label:[a] | goto label; | N/A | Pascal(FPC) | break; | continue; | Visual Basic | Exit block | N/A | label: | GoTo label | Visual Basic .NET | Continue block | 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) | |
^a Pascal has declaration blocks. See Perbandingan -- programming languages (basic instructions)#Functions. ^b label must be a number between 1 and 99999. See reflection for calling and declaring functions by strings. | calling a function | basic/void function | value-returning function | required main function |
---|
ALGOL 68 | foo«(parameters)»; | proc foo = «(parameters)» void: ( instructions ); | proc foo = «(parameters)» rettype: ( instructions ...; retvalue ); | 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) | C# | static void Main(«string[] args») { instructions } or static int Main(«string[] args») { instructions } | 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} | 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 } | Common Lisp | (foo «parameters») | (defun foo («parameters») instructions) or (setf (symbol-function 'symbol)lambda) | (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] «labellabel declarations» «constconstant declarations» «typetype declarations» «varvariable declarations» «local function declarations» begininstructions end; | function foo«(parameters)»: type; «forward;»[a] «labellabel declarations» «constconstant declarations» «typetype declarations» «varvariable declarations» «local function declarations» begininstructions; foo := value end; | program name; «labellabel declarations» «constconstant declarations» «typetype declarations» «varvariable declarations» «function declarations» begininstructions 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 | Function Foo(«parameters») As type instructions Return value End Function | Sub Main(«ByVal CmdArgs() As String») instructions End Sub or Function Main(«ByVal CmdArgs() As String») As Integerinstructions End Function | 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; } | Perl 6 | 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 | Windows PowerShell | foo« parameters» | function foo «(parameters)» { instructions }; or function foo { «param(parameters)» instructions } | function foo «(parameters)» { instructions … return value }; or function foo { «param(parameters)» instructions … return value } | 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»)
requirepreconditions doinstructions ensurepostconditions end | foo («parameters»): type
requirepreconditions doinstructions Result := value ensurepostconditions end | [b] |
^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. [c] 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 |
---|
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)); etc. | 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); or 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) or 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); or double = Double.parseDouble(string); | string = Integer.toString(integer); | string = Float.toString(float); or string = Double.toString(double); | JavaScript[a] | integer = parseInt(string); | float = parseFloat(string); or float = new Number (string) or float = Number (string) or float = string*1; | string = number.toString (); or string = new String (number); or string = String (number); or string = number+""; | Go | integer, error = strconv.Atoi(string) or integer, error = strconv.ParseInt(string, 10, 0) | long, error = strconv.ParseInt(string, 10, 64) | float, error = strconv.ParseFloat(string, 64) | string = strconv.Itoa(integer) or string = strconv.FormatInt(integer, 10) or string = fmt.Sprint(integer) | string = strconv.FormatFloat(float) or string = fmt.Sprint(float) | 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) or double = CDbl(string) | string = CStr(number) | Visual Basic .NET | 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); or float = (float)string; | string = "number"; or string = strval(number); or string = (string)number; | Perl[b] | number = 0 + string; | string = "number"; | Perl 6 | number = +string; | string = ~number; | Ruby | integer = string.to_i or integer = Integer(string) | float = string.to_f or float = Float(string) | string = number.to_s | 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 |
^a JavaScript only uses floating point numbers so there are some technicalities.[4] ^b Perl doesn't have separate types. Strings and numbers are interchangeable. | read from | write to |
---|
stdin | stdout | stderr |
---|
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] | C (C99) | scanf(format, &x); or fscanf(stdin, format, &x); [b] | printf( format, x); or fprintf(stdout, format, x); [c] | fprintf(stderr, format, x );[d] | Objective-C | data = [[NSFileHandle fileHandleWithStandardInput] readDataToEndOfFile]; | [[NSFileHandle fileHandleWithStandardOutput] writeData:data]; | [[NSFileHandle fileHandleWithStandardError] writeData:data]; | C++ | «std::»cin >> x; or «std::»getline(«std::»cin, str); | «std::»cout << x; | «std::»cerr << x; or «std::»clog << x; | C# | x = Console.Read(); or x = Console.ReadLine(); | Console.Write(«format, »x); or Console.WriteLine(«format, »x); | Console.Error.Write(«format, »x); or Console.Error.WriteLine(«format, »x); | D | x = std.stdio.readln() | std.stdio.write(x) or std.stdio.writeln(x) or std.stdio.writef(format, x) or std.stdio.writefln(format, x) | stderr.write(x) or stderr.writeln(x) or std.stdio.writef(stderr, format, x) or std.stdio.writefln(stderr, format, x) | Java | x = System.in.read(); or x = new Scanner(System.in).nextInt(); or x = new Scanner(System.in).nextLine(); | System.out.print(x); or System.out.printf(format, x); or System.out.println(x); | System.err.print(x); or System.err.printf(format, x); or System.err.println(x); | Go | fmt.Scan(&x) or fmt.Scanf(format, &x) or x = bufio.NewReader(os.Stdin).ReadString( '\n') | fmt.Println(x) or fmt.Printf(format, x) | fmt.Fprintln(os.Stderr, x) or fmt.Fprintf(os.Stderr, format, x) | 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); | N/A | Visual Basic | Input« prompt,» x | Print x or ? x | Visual Basic .NET | x = Console.Read() or x = Console.ReadLine() | Console.Write(«format, »x) or Console.WriteLine(«format, »x) | Console.Error.Write(«format, »x) or Console.Error.WriteLine(«format, »x) | 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; | Perl 6 | $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 |
^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.[7]
| Argument values | Argument counts | Program name / Script 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 | 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[a] | N/A | App.Path | Visual Basic .NET | CmdArgs(n) | CmdArgs.Length | [Assembly].GetEntryAssembly().Locatio n | 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 | Perl | $ARGV[n] | scalar(@ARGV) | $0 | Perl 6 | @*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 args !! n } | do { args <- System.getArgs; return length args } | System.getProgName |
- ^a The command-line arguments in Visual Basic are not separated. A split function Split(string) is required for separating them.
Execution of commands | Shell command | Execute program | Replace current program with new executed program |
---|
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.She ll(command «, WindowStyle» «, isWaitOnReturn») | System.Diagnostics.Process.Start(path, argstring) | | 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 | (shell 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` | | 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) | | os.execv(path, args) | S-Lang | system(command) | | | Fortran | CALL SYSTEM (command, status) or status = SYSTEM (command)[a] | | | Windows PowerShell | [Diagnostics.Process]::Start(command) | «Invoke-Item »program arg1 arg2 … | |
^a Compiler-dependent extension.[8] References |
| |