Comparison of programming languages (basic instructions): Difference between revisions
Line 1,457: | Line 1,457: | ||
| rowspan=4| '''break;''' |
| rowspan=4| '''break;''' |
||
| rowspan=4| '''continue;''' |
| rowspan=4| '''continue;''' |
||
| rowspan= |
| rowspan=8| label''':''' |
||
| rowspan=4| '''goto''' label''';''' |
| rowspan=4| '''goto''' label''';''' |
||
| rowspan=3 {{n/a}} |
| rowspan=3 {{n/a}} |
||
Line 1,480: | Line 1,480: | ||
| '''break''' «levels»''';''' |
| '''break''' «levels»''';''' |
||
| '''continue''' «levels»''';''' |
| '''continue''' «levels»''';''' |
||
⚫ | |||
| {{n/a}} |
|||
| '''goto''' ''';''' |
|||
| '''return()''' ''';''' |
| '''return()''' ''';''' |
||
|- |
|- |
||
Line 1,487: | Line 1,486: | ||
| '''last''' «label»''';''' |
| '''last''' «label»''';''' |
||
| '''next''' «label»''';''' |
| '''next''' «label»''';''' |
||
| label''':''' |
|||
⚫ | |||
| |
| |
||
|- |
|- |
Revision as of 07:14, 14 September 2009
This article needs additional citations for verification. (February 2009) |
Comparison of programming languages is a common topic of discussion among software engineers. Basic instructions of several programming languages are compared here.
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.
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 | ||
C (C99 fixed-width) | int8_t | uint8_t | int16_t | uint16_t | int32_t | uint32_t | int64_t | uint64_t | int | unsigned int | — |
C (C99 variable-width) | signed char | unsigned char | short[a] | unsigned short[a] | long[a] | unsigned long[a] | long long[a] | unsigned long long[a] | |||
C++ | |||||||||||
Objective-C | signed char | unsigned char | short[a] | unsigned short[a] | long[a] | unsigned long[a] | long long[a] | unsigned long long[a] | int or NSInteger |
unsigned int or NSUInteger | |
C# | sbyte | byte | short | ushort | int | uint | long | ulong | — | ||
Java | byte | — | char[b] | — | — | java.math.BigInteger | |||||
Common Lisp[1] | bignum | ||||||||||
Scheme | |||||||||||
Pascal (FPC) | shortint | byte | smallint | word | longint | longword | int64 | qword | integer | cardinal | — |
Visual Basic | — | Byte | Integer | — | Long | — | — | — | — | ||
Visual Basic .NET | SByte | Short | UShort | Integer | UInteger | Long | ULong | ||||
Python 2.x | — | — | int | — | — | — | long | ||||
Python 3.x | — | — | — | — | — | int | |||||
JavaScript | — | — | — | — | — | — | |||||
S-Lang | — | — | — | — | — | — | |||||
FORTRAN 77 | — | INTEGER | — | — | — | ||||||
PHP | — | — | int | — | — | — | [d] | ||||
Perl 5 | —[c] | —[c] | —[c] | —[c] | —[c] | Math::BigInt | |||||
Ruby | — | — | Fixnum | — | — | — | Bignum | ||||
Windows PowerShell | — | — | — | — | — | — | |||||
OCaml | — | — | int32 | — | int64 | — | int or nativeint |
open Big_int;; big_int | |||
F# | sbyte | byte | int16 | uint16 | int32 or int | uint32 | uint64 | nativeint | unativeint | bigint | |
Standard ML | — | Word8.word | — | 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 | — |
^a The C and C++ languages do not specify the exact width of the integer types "short", "int", "long", and (C99, C++0x) "long long", so they are implementation-dependent. The "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 also defines the "[u]intN_t" exact-width types in the stdint.h header. See C syntax#Integral types for more information.
^b Commonly used for characters.
^c Perl 5 does not have distinct types. Integers, floating point numbers, strings, etc. are all considered "scalars".
^d PHP has two arbitrary-precision libraries. The BCMath library just uses strings as datatype. The GMP library uses an internal "resource" type.
Single precision | Double precision | Processor dependent | |
---|---|---|---|
C | float[a] | double | —[a] |
Objective-C | |||
C++ (STL) | |||
C# | float | — | |
Java | |||
Common Lisp | |||
Scheme | |||
Pascal (Free Pascal) | single | double | real |
Visual Basic | Single | Double | — |
Visual Basic .NET | |||
Python | — | float | |
JavaScript | Number[2] | — | |
S-Lang | |||
FORTRAN 77 | REAL | DOUBLE PRECISION | |
PHP | float | ||
Perl | |||
Ruby | — | Float | — |
Windows PowerShell | |||
OCaml | — | float | |
F# | float32 | ||
Standard ML | — | real | |
Haskell (GHC) | Float | Double | |
Eiffel | REAL_32 | REAL_64 |
^a declarations of single precision often are not honored
Integer | Single precision | Double precision | |
---|---|---|---|
C (C99) [3] | — | float complex | double complex |
C++ (STL) | — | «std::»complex<float> | «std::»complex<double> |
C# | — | — | |
Java | — | — | — |
Objective-C | — | — | — |
Common Lisp | |||
Scheme | |||
Pascal | — | — | |
Visual Basic | — | — | |
Visual Basic .NET | — | — | |
Perl | Math::Complex | ||
Python | complex | ||
JavaScript | — | — | |
S-Lang | — | — | |
FORTRAN 77 | COMPLEX | ||
Ruby | Complex | — | Complex |
Windows PowerShell | — | — | |
OCaml | — | — | Complex.t |
F# | |||
Standard ML | — | — | — |
Haskell (GHC) | — | Complex.Complex Float | Complex.Complex Double |
Eiffel | — | — | — |
Other variable types
Text | Boolean | Enumeration | Object/Universal | ||
---|---|---|---|---|---|
Character | String[a] | ||||
C (C99) | char | — | 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 | ||
Common Lisp | |||||
Scheme | |||||
Pascal (ISO) | char | — | boolean | (item1, item2, ...) | — |
Object Pascal (Delphi) | string | variant | |||
Visual Basic | — | String | Boolean | Enum name
item2 ... |
Variant |
Visual Basic .NET | Char | Object | |||
Python | —[d] | str | bool | object | |
JavaScript | —[d] | String | Boolean | Object | |
S-Lang | |||||
FORTRAN 77 | CHARACTER*1 | — | LOGICAL | — | |
PHP | —[d] | string | bool | object | |
Perl | —[d] | ||||
Ruby | —[d] | String | Object[c] | Object | |
Windows PowerShell | |||||
OCaml | char | string | bool | —[e] | — |
F# | type name = item1 = value | item2 = value | ... | obj | |||
Standard ML | —[e] | — | |||
Haskell (GHC) | Char | String | Bool | —[e] | — |
Eiffel | CHARACTER | STRING | BOOLEAN | — | 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
Derived types
fixed size array | dynamic size array | |||
---|---|---|---|---|
one-dimensional array | multi-dimensional array | one-dimensional array | multi-dimensional array | |
C (C99) | [a] | [a] | ||
C++ (STL) | «std::»vector<type> | |||
C# | type[size] | type[size1, size2,...] | System.Collections.ArrayList or System.Collections.Generic.List<type> |
|
Java | type[size][b] | type[size1][size2]...[b] | ArrayList or ArrayList<type> | |
Objective-C | NSMutableArray | |||
JavaScript | — | — | Array[d] | |
Common Lisp | ||||
Scheme | ||||
Pascal | array[first..last] of type[c] | array[first1..last1] of array[first2..last2] ... of type [c] or |
||
Visual Basic | ||||
Visual Basic .NET | System.Collections.ArrayList or System.Collections.Generic.List(Of type) |
|||
Python | list | |||
S-Lang | ||||
FORTRAN 77 | ||||
PHP | array | |||
Perl | ||||
Ruby | Array | |||
Windows PowerShell | ||||
OCaml | type array | type array ... array | ||
F# | type [] or type array | type [,,...] | System.Collections.ArrayList or System.Collections.Generic.List<type> |
|
Standard ML | ||||
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 use 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 | |||
C (C99) | struct «name» {type name;...}; | — | — | union {type name;...}; |
Objective-C | ||||
C++ | —[a][b] | — | ||
C# | struct name {type name;...} | — | ||
Java | —[a] | |||
JavaScript | — | |||
Common Lisp | (cons val1 val2)[c] | |||
Scheme | — | |||
Pascal | record
... |
— | — | record
value: type; ... |
Visual Basic | ||||
Visual Basic .NET | Structure name
... |
|||
Python | —[a] | «(»val1, val2, val3, ... «)» | — | |
S-Lang | struct {name [=value], ...} | |||
FORTRAN 77 | ||||
PHP | —[a] | |||
Perl | —[d] | — | ||
Ruby | OpenStruct.new({:name => value}) | |||
Windows PowerShell | ||||
OCaml | type name = {«mutable» name : type;...} | «(»val1, val2, val3, ... «)» | type name = Foo «of type» | Bar «of type» | ... | |
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.
^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
Declarations
variable | constant | type synonym | |
---|---|---|---|
C (C99) | type name «= initial_value»; | enum{ name = value }; | typedef type synonym; |
Objective-C | |||
C++ | const type name = value; | ||
C# | using synonym = type; | ||
Java | final type name = value; | — | |
JavaScript | var name «= initial_value»; | const name = value; | |
Common Lisp | (defparameter name initial_value) | (defconstant name value) | (deftype synonym () 'type) |
Scheme | (define name initial_value) | ||
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 | — | synonym = type[b] |
S-Lang | name = initial_value; | typedef struct {...} typename | |
FORTRAN 77 | type name | ||
PHP | $name = initial_value; | define("name", "value"); | — |
Perl | «my» $name = initial_value;[c] | use constant name => value; | |
Ruby | name = initial_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 |
^a Pascal has declaration blocks. See Comparison of 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.
Conditional statements
if | else if | select case | conditional expression | |
---|---|---|---|---|
C (C99) | if (condition) {instructions} «else {instructions}» |
if (condition) {instructions} else if (condition) {instructions} ... «else {instructions}» |
switch (variable) {
... «default: instructions» |
condition ? valueIfTrue : valueIfFalse |
Objective-C | ||||
C++ (STL) | ||||
Java | ||||
JavaScript | ||||
PHP | ||||
C# | switch (variable) {
... «default: instructions; «jump statement;»» | |||
Windows PowerShell | if (condition) { instructions } elseif (condition) { instructions } ... «else { instructions }» |
switch (variable) { case1 { instructions «break;» ... «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) {
... «default { instructions }» |
condition ? valueIfTrue : valueIfFalse |
Ruby | if condition
|
if condition
«else
|
case variable when case1
«else
| |
Common Lisp | (when condition instructions) or (if condition (progn instructions) «(progn instructions)») |
(cond (condition1 instructions) (condition2 instructions) ... «(t instructions)») | (case (variable) (case1 instructions) (case2 instructions) ... «(t instructions)») | (if condition valueIfTrue valueIfFalse) |
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)») | |
Pascal | if condition then begin
«else begin
|
if condition then begin
else if condition then begin
... «else begin
|
case variable of
... «else: instructions» |
|
Oberon-2 | IF condition THEN
|
IF condition THEN
|
CASE expression OF case1a , case1b :
«ELSE
|
|
Visual Basic | If condition Then
|
If condition Then
«Else
|
Select Case variable Case case1
«Case Else
|
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» |
— | 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 77 | IF condition THEN instructions «ELSE instructions» ENDIF |
IF condition THEN instructions ELSEIF condition THEN instructions ... «ELSE instructions» ENDIF |
index = f(variable) GOTO ( c1, c2, ... cn) index ... c1 instructions |
|
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
| 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 of
| 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
| otherwise = expression |
case value of {
pattern2 -> expression; ... «_ -> expression» | |
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 | |
---|---|---|---|---|
C (C99) | while (condition) { instructions } | do { instructions } while (condition) | for («type» i = first; i <= last; ++i) { instructions } | — |
Objective-C | for (type item in set) { instructions } | |||
C++ (STL) | «std::»for_each(start, end, function) | |||
C# | foreach (type item in set) { instructions } | |||
Java | for (type item : set) { instructions } | |||
JavaScript | for (var i = first; i <= last; i++) { instructions } | for (var property in object) { instructions } | ||
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 } | ||
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 } |
Ruby | while condition
or until notcondition
|
begin
or begin
|
for i in first...last
or first.upto(last-1) { |i| instructions } |
for item in set
or set.each { |item| instructions } |
Common Lisp | (loop while condition do instructions) or (do () (notcondition) instructions) |
(loop do instructions while condition) | (loop for i from first to last 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) |
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) |
Pascal | while condition do begin
|
repeat
|
for i := first «step 1» to last do begin
|
— |
Visual Basic | Do While condition
or Do Until notcondition
|
Do
or Do
|
For i = first To last «Step 1»
|
For Each item In set
|
Visual Basic .NET | For i «As type» = first To last «Step 1»
|
For Each item As type In set
| ||
Python | while condition : Tab ↹ instructions «else: Tab ↹ instructions» |
— | 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 77 | — | DO nnnn I = first,last instructions nnnn CONTINUE |
— | |
Forth | BEGIN « instructions » condition WHILE instructions REPEAT | BEGIN instructions condition UNTIL | limit start DO instructions LOOP | — |
OCaml | while condition do instructions done | — | for i = first to last-1 do instructions done | Array.iter (fun item -> instructions) array List.iter (fun item -> instructions) list |
F# | while condition do Tab ↹ instructions |
— | 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 ) | — | Array.app (fn item => instructions) array app (fn item => instructions) list | |
Haskell (GHC) | — | Control.Monad.forM_ [0..N-1] (\i -> do instructions) | Control.Monad.forM_ list (\item -> do instructions) | |
Eiffel | from
|
^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 }» | ? | |
PHP | try { instructions } catch (exception) { instructions } ... | assert(condition); | |
S-Lang | try { instructions } catch «exception» { instructions } ... «finally { instructions }» | ? | |
Windows PowerShell | trap «[exception]» { instructions } ... 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 } | ? |
Ruby | raise exception | begin
«else
|
|
Common Lisp | (error exception) | (handler-case (progn instructions) (exception instructions) ...) | ? |
Scheme (R6RS) | (raise exception) | (guard (con (condition instructions) ...) instructions) | ? |
Pascal | raise Exception.Create() | try Except on E: exception do begin instructions end; end; | ? |
Visual Basic | — | ? | |
Visual Basic .NET | Throw exception | Try
«Finally
|
Debug.Assert(condition) |
Python | raise exception | try: Tab ↹ instructions except «exception»: Tab ↹ instructions ... «else: Tab ↹ instructions» «finally: Tab ↹ instructions» |
assert condition |
FORTRAN 77 | — | ? | |
Forth | code THROW | xt CATCH ( code or 0 ) | — |
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 |
Other control flow statements
exit block(break) | continue | label | branch (goto) | return value from generator | |
---|---|---|---|---|---|
C (C99) | break; | continue; | label: | goto label; | — |
Objective-C | |||||
C++ (STL) | |||||
C# | yield return value; | ||||
Java | break «label»; | continue «label»; | — | ||
JavaScript | yield value«;» | ||||
PHP | break «levels»; | continue «levels»; | goto label; | return() ; | |
Perl | last «label»; | next «label»; | |||
Common Lisp | (return) or (return-from block) |
(go tag) | |||
Scheme | |||||
Pascal(ISO) | — | label:[a] | goto label; | — | |
Pascal(FPC) | break; | continue; | |||
Visual Basic | Exit block | — | label: | GoTo label | |
Visual Basic .NET | Continue block | ||||
Python | break | continue | — | yield value | |
S-Lang | break; | continue; | |||
FORTRAN 77 | — | a number in columns 1 to 5 | GOTO label | — | |
Ruby | break | next | |||
Windows PowerShell | break« label» | continue | |||
OCaml | — | ||||
F# | |||||
Standard ML | |||||
Haskell (GHC) |
^a Pascal has declaration blocks. See Comparison of programming languages (basic instructions)#Functions.
See reflection for calling and declaring functions by strings.
calling a function | basic/void function | value-returning function | required main function | |
---|---|---|---|---|
C (C99) | foo(«parameters»); | void foo(«parameters») { instructions } | type foo(«parameters») { instructions ... return value; } | «global declarations» int main(«int argc, char *argv[]») {
|
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 } | |||
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; } | — | |
Common Lisp | (foo «parameters») | (defun foo (parameters) instructions) | (defun foo (parameters) instructions... return_value) | |
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)) | ||
Pascal | foo«(parameters)» | procedure foo«(parameters)»; «forward;»[a] «label
begin
|
function foo«(parameters)»: type; «forward;»[a] «label
begin
foo := value |
program name; «label
begin
|
Visual Basic | Foo(«parameters») | Sub Foo(«parameters»)
|
Function Foo(«parameters») As type
Foo = value |
Sub Main()
|
Visual Basic .NET | Function Foo(«parameters») As type
Return value |
Sub Main(«ByVal CmdArgs() As String»)
or Function Main(«ByVal CmdArgs() As String») As Integer
| ||
Python | foo(«parameters») | def foo(«parameters»): Tab ↹ instructions |
def foo(«parameters»): Tab ↹ instructions Tab ↹ return value |
— |
S-Lang | foo(«parameters» «;qualifiers») | define foo («parameters») { instructions } | define foo («parameters») { instructions ... return value; } | public define slsh_main () { instructions } |
FORTRAN 77 | SUBROUTINE FOO«(parameters)»
|
type FUNCTION FOO«(parameters)»
FOO = value |
PROGRAM main | |
Forth | «parameters» FOO | : FOO « stack effect comment: ( before -- after ) »
|
— | — |
PHP | foo(«parameters») | function foo(«parameters») { instructions } | function foo(«parameters») { instructions ... return value; } | — |
Perl | foo(«parameters») or &foo«(parameters)» |
sub foo { «my (parameters) = @_;» instructions } | sub foo { «my (parameters) = @_;» instructions... «return» value; } | |
Ruby | foo«(parameters)» | def foo«(parameters)»
|
def foo«(parameters)»
«return» value | |
Windows PowerShell | 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»)
|
foo («parameters»): type
|
[b] |
^a Pascal requires "forward;" for forward declarations.
^b Eiffel allows the specification of an application's root class and feature.
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 | |
---|---|---|---|---|---|
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# | integer = int.Parse(string); | long = long.Parse(string); | float = float.Parse(string); or double = double.Parse(string); |
string = number.ToString(); | |
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 = string*1; |
— | string = number.toString (); or string = new String (number); or string = number+""; | |
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)) | |||
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 77 | READ(string,format) integer | — | READ(string,format) float | 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"; | |||
Ruby | integer = string.to_i | float = string.to_f | 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.[2]
^b Perl doesn't have separate types. Strings and numbers are interchangeable.
read from | write to | ||
---|---|---|---|
stdin | stdout | stderr | |
C (C99) | scanf(format, &x); or fscanf(stdin, format, &x); [a] |
printf( format, x); or fprintf(stdout, format, x); [b] |
fprintf(stderr, format, x );[c] |
Objective-C | |||
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); |
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); |
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) |
Pascal | read(x); or readln(x); |
write(x); or writeln(x); |
— |
Visual Basic | Input« prompt,» x | Print x or ? x | |
Visual Basic .NET | x = Console.Read() or x = Console.ReadLine() |
Console.Write(«format, »x) or Console.WriteLine(«format, »x) |
Console.Error.Write(«format, »x) or Console.Error.WriteLine(«format, »x) |
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 77 | READ(5,format) variable names | WRITE(6,format) expressions | — |
Forth | buffer length ACCEPT ( # chars read ) KEY ( char ) |
buffer length TYPE char EMIT |
— |
PHP | $x = fgets(STDIN); or $x = fscanf(STDIN, format); |
print x; or echo x; or printf(format, x); |
fprintf(STDERR, format, x); |
Perl | $x = <>; or $x = <STDIN>; |
print x; or printf format, x; |
print STDERR x; or printf STDERR format, x; |
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 gets(x) and fgets(x, length, stdin) read unformatted text from stdin. Use of gets is not recommended.
^b puts(x) and fputs(x, stdout) write unformatted text to stdout.
^c fputs(x, stderr) writes unformatted text to stderr
Reading command-line arguments
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 | ||
JavaScript Windows Script Host implementation |
WScript.Arguments(n) | WScript.Arguments.length | ? |
Common Lisp | ? | ? | ? |
Scheme (R6RS) | (list-ref (command-line) n) | (length (command-line)) | first argument |
Pascal | ParamStr(n) | ParamCount | first argument |
Visual Basic | Command | — | ? |
Visual Basic .NET | CmdArgs(n) | CmdArgs.Length | [Assembly].GetEntryAssembly().Location |
Python | sys.argv[n] | len(sys.argv) | first argument |
S-Lang | __argv[n] | __argc | first argument |
FORTRAN 77 | — | ? | |
PHP | $argv[n] | $argc | first argument |
Perl | $ARGV[n] | scalar(@ARGV) | $0 |
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 |
Execution of commands
Shell command | Execute program | |
---|---|---|
C | system("command"); | execl(path, args); or execv(path, arglist); |
C++ | ||
C# | System.Diagnostics.Process.Start(path, argstring); | |
F# | ||
Visual Basic | Interaction.Shell(command «, WindowStyle» «, isWaitOnReturn») | |
Visual Basic .NET | Microsoft.VisualBasic.Interaction.Shell(command «, WindowStyle» «, isWaitOnReturn») | System.Diagnostics.Process.Start(path, argstring) |
Java | Runtime.exec(command); or new ProcessBuilder(command).start(); |
|
JavaScript Windows Script Host implementation |
WScript.CreateObject ("WScript.Shell").Run(command «, WindowStyle» «, isWaitOnReturn»); | |
Common Lisp | (shell command) | |
Scheme | (system command) | |
Pascal | system(command); | |
OCaml | Sys.command command, Unix.open_process_full command env (stdout, stdin, stderr),... | Unix.execv prog args, Unix.execve prog args env, Unix.create_process prog args new_stdin new_stdout new_stderr, ... |
Standard ML | OS.Process.system command | |
Haskell (GHC) | System.system command | |
Perl | system(command) or $output = `command` |
exec(path, args) |
Ruby | system(command) or output = `command` |
exec(path, args) |
PHP | system(command) or output = `command` |
exec(command) |
Python | os.system(command) or subprocess.Popen(command) |
os.execv(path, args) |
S-Lang | system(command) | |
Windows PowerShell | [Diagnostics.Process]::Start(command) | «Invoke-Item »program arg1 arg2 … |