Jump to content

Comparison of programming languages (basic instructions)

From Wikipedia, the free encyclopedia
This is an old revision of this page, as edited by Short Circuit (talk | contribs) at 04:29, 3 May 2010 (Link to on-wiki Program Chrestomathy page; that *is* what this is an example of.). The present address (URL) is a permanent link to this revision, which may differ significantly from the current revision.
Comparison of
programming languages
Comparison of individual
languages

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

Integers

8 bit (byte) 16 bit (short integer) 32 bit 64 bit (long integer) Word size Arbitrarily precise (bignum)
Signed Unsigned Signed Unsigned Signed Unsigned Signed Unsigned Signed Unsigned
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 — System.Numerics.BigInteger (.NET 4.0)
Java byte — char[b] — — java.math.BigInteger
Common Lisp[1] bignum
Scheme
Pascal (FPC) shortint byte smallint word longint longword int64 qword integer cardinal —
Gambas — Byte Short — Integer — Long —
Visual Basic — Byte Integer — Long — — — —
Visual Basic .NET SByte Short UShort Integer UInteger Long ULong System.Numerics.BigInteger (.NET 4.0)
Python 2.x — — int — — — long
Python 3.x — — — — — int
S-Lang — — — — — —
Fortran INTEGER(KIND = n)[e] — INTEGER(KIND = n)[e] — INTEGER(KIND = n)[e] — INTEGER(KIND = n)[e] —
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.
^e The value of "n" is provided by the SELECTED_INT_KIND[2] intrinsic function.

Floating point

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[3] —
S-Lang
Fortran REAL(KIND = n)[b]
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
^b The value of "n" is provided by the SELECTED_REAL_KIND[4] intrinsic function.

Complex numbers

Integer Single precision Double precision
C (C99) [5] — 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 COMPLEX(KIND = n)[a]
Ruby Complex — Complex
Windows PowerShell — —
OCaml — — Complex.t
F#
Standard ML — — —
Haskell (GHC) — Complex.Complex Float Complex.Complex Double
Eiffel — — —

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

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
    item1
    item2
    ...
End Enum 		Variant
Visual Basic .NET Char Object
Python —[d] str bool object
JavaScript —[d] String Boolean Object
S-Lang
Fortran CHARACTER(LEN = *) CHARACTER(LEN = :), allocatable LOGICAL(KIND = n)[f] CLASS(*)
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
^f The value of "n" is provided by the SELECTED_INT_KIND[7] intrinsic function.

Derived types

Array

Further information: Comparison of programming languages (array)
fixed size array dynamic size array
one-dimensional array multi-dimensional array one-dimensional array multi-dimensional array
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
array[first1..last1, first2..last2, ...] of type [c]

— —
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
Ruby Array
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 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
    name: type;
    ...
end 		— — record
    case type of
    value: (types);
    ...
end
Visual Basic
Visual Basic .NET Structure name
    Dim name As type
    ...
End Structure
Python —[a] «(»val1, val2, val3, ... «)» —
S-Lang struct {name [=value], ...}
Fortran TYPE name
    type :: name
    ...
END TYPE
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 structs in C++ are actually classes, but POD objects are in fact records.
^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# type name «= initial_value»;
var name = value; 		using synonym = type;
Java type name «= initial_value»; final type name = value; —
JavaScript var name «= initial_value»; const name = value;
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)
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 type name type, PARAMETER :: name = value
PHP $name = initial_value; define("name", value);
const name = value (5.3+) 		—
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.

Control flow

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) {
    case case1: instructions «break;»
    ...
    «default: instructions»
} 		condition ? valueIfTrue : valueIfFalse
Objective-C
C++ (STL)
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 }»}
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
Ruby if condition
    instructions
«else
    instructions»
end 		if condition
    instructions
elsif condition
    instructions
...
«else
    instructions»
end 		case variable
when case1
    instructions
...
«else
    instructions»
end
Common Lisp (when condition
    instructions)
or
(unless condition
    instructions)
or
(if condition
    (progn instructions)
    «(progn instructions)»)
 (cond (condition1 instructions)
    (condition2 instructions)
    ...
    «(t instructions)»)
 (case (variable)
    (case1 instructions)
    (case2 instructions)
    ...
    «(otherwise 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
    instructions
end
«else begin
    instructions
end»[c] 		if condition then begin
    instructions
end
else if condition then begin
    instructions
end
...
«else begin
    instructions
end»[c] 		case variable of
    case1: instructions
    ...
    «else: instructions»
end[c]
Oberon-2 IF condition THEN
    instructions
«ELSE
    instructions»
END[c] 		IF condition THEN
    instructions
ELSIF condition THEN
    instructions
«ELSE
    instructions»
END 		CASE expression
OF case1a , case1b :
    instructions
| case2a , case2b :
    instructions
...
«ELSE
    instructions»
END
Visual Basic If condition Then
    instructions
«Else
    instructions»
End If 		If condition Then
    instructions
ElseIf condition Then
    instructions
...
«Else
    instructions»
End If 		Select Case variable
Case case1
    instructions
...
«Case Else
    instructions»
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» 		— 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
ELSE
    instructions
ENDIF 		IF (condition) THEN
    instructions
ELSEIF (condition) THEN
    instructions
...
ELSE
    instructions
ENDIF 		SELECT CASE(variable)
    CASE (case1)
      instructions
    ...
    CASE DEFAULT
      instructions
END SELECT
Forth condition IF instructions « ELSE instructions» THEN condition IF instructions ELSE condition IF instructions THEN THEN value CASE
case OF instructions ENDOF
case OF instructions ENDOF
     default instructions
ENDCASE 		condition IF valueIfTrue ELSE valueIfFalse THEN
OCaml if condition then begin instructions end «else begin instructions end» if condition then begin instructions end else if condition then begin instructions end ... «else begin instructions end» match value with
    pattern1 -> expression
    |     pattern2 -> expression
    ...
    «| _ -> expression»[b]
 if condition then valueIfTrue else valueIfFalse
F# 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
    pattern1 => expression
    |     pattern2 => expression
    ...
    «| _ => expression»[b]
Haskell (GHC) if condition then expression else expression or
when condition (do instructions) or
unless notcondition (do instructions) 		result | condition = expression
    | condition = expression
    | otherwise = expression
 case value of {
    pattern1 -> expression;
    pattern2 -> expression;
    ...
    «_ -> expression»
}[b]
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.

Loop statements

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
    instructions
end
or
until notcondition
    instructions
end 		begin
    instructions
end while condition
or
begin
    instructions
end until notcondition 		for i in first...last
    instructions
end
or
first.upto(last-1) { |i| instructions } 		for item in set
    instructions
end
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 «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)
Pascal while condition do begin
    instructions
end 		repeat
    instructions
until notcondition; 		for i := first «step 1» to last do begin
    instructions
end;[a] 		—
Visual Basic Do While condition
    instructions
Loop
or
Do Until notcondition
    instructions
Loop 		Do
    instructions
Loop While condition
or
Do
    instructions
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» 		— 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 		—
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
    setup
until
    condition
loop
    instructions
end

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

Exceptions

Further information: Exception handling syntax
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 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 } ?
Ruby raise exception begin
    instructions
rescue exception
    instructions
...
«else
    instructions»
«ensure
    instructions»
end
Common Lisp (error "exception") or
(error (make-condition
    type
    arguments))
 (handler-case
    (progn instructions)
    (exception instructions)
    ...)
or
(handler-bind
    (condition
      (lambda
      instructions
      «invoke-restart restart args»))
    ...)[a]
 (assert condition) or
(assert condition
    «(place)
    «error»»)
or
(check-type var type)
Scheme (R6RS) (raise exception) (guard (con (condition instructions) ...) instructions) ?
Pascal raise Exception.Create() try Except on E: exception do begin instructions end; end; ?
Visual Basic — ?
Visual Basic .NET Throw exception Try
    instructions
Catch «exception» «When condition»
    instructions
...
«Finally
    instructions»
End Try 		Debug.Assert(condition)
Python raise exception try:
Tab ↹ instructions
except «exception»:
Tab ↹ instructions
...
«else:
Tab ↹ instructions»
«finally:
Tab ↹ instructions» 		assert condition
Fortran —
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

^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
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) or
(loop-finish) 		(tagbody tag
      ...
      tag
    ...)
(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 EXIT CYCLE label[b] 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.
^b label must be a number between 1 and 99999.

Functions

See reflection for calling and declaring functions by strings.

calling a function basic/void function value-returning function required main function
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 }
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)
or
(setf (symbol-function 'symbol)
    lambda)
 (defun foo («parameters»)
    ...
    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
    label declarations»
«const
    constant declarations»
«type
    type declarations»
«var
    variable declarations»
«local function declarations»
begin
    instructions
end; 		function foo«(parameters)»: type; «forward;»[a]
«label
    label declarations»
«const
    constant declarations»
«type
    type declarations»
«var
    variable declarations»
«local function declarations»
begin
    instructions;
    foo :=     value
end; 		program name;
«label
    label declarations»
«const
    constant declarations»
«type
    type declarations»
«var
    variable declarations»
«function declarations»
begin
    instructions
end.
Visual Basic Foo(«parameters») Sub Foo(«parameters»)
    instructions
End Sub 		Function Foo(«parameters») As type
    instructions
    Foo = value
End Function 		Sub Main()
    instructions
End Sub
Visual Basic .NET 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 Integer
    instructions
End Function
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 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 -- after ) »
    instructions
 ; 		— —
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)»
    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»)
    require
      preconditions
    do
      instructions
    ensure
      postconditions
    end
 foo («parameters»): type
    require
      preconditions
    do
      instructions
      Result := value
    ensure
      postconditions
    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]

Type conversions

Where string is a signed decimal number:

string to integer string to long integer string to floating point integer to string floating point to string
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 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";
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.[3]
^b Perl doesn't have separate types. Strings and numbers are interchangeable.

Standard Input and Standard Output

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 READ(*,format) variable names or
READ(INPUT_UNIT,format) variable names[d] 		WRITE(*,format) expressions or
WRITE(OUTPUT_UNIT,format) expressions[d] 		WRITE(ERROR_UNIT,format) expressions[d]
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
^d INPUT_UNIT, OUTPUT_UNIT, ERROR_UNIT are defined in the ISO_FORTRAN_ENV module [8].

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[a] — App.Path
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 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
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 is not separated. A split function Split(string) is required for separating them.

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)
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 [9].

See Also

References

  1. ^ http://www.lispworks.com/documentation/HyperSpec/Front/index.htm
  2. ^ http://fortranwiki.org/fortran/show/selected_int_kind
  3. ^ a b 8.5 The Number Type
  4. ^ http://fortranwiki.org/fortran/show/selected_real_kind
  5. ^ http://www.gnu.org/software/libc/manual/html_node/Complex-Numbers.html#Complex-Numbers
  6. ^ http://fortranwiki.org/fortran/show/selected_real_kind
  7. ^ http://fortranwiki.org/fortran/show/selected_int_kind
  8. ^ http://fortranwiki.org/fortran/show/iso_fortran_env
  9. ^ http://gcc.gnu.org/onlinedocs/gfortran/SYSTEM.html#SYSTEM
Retrieved from "https://en.wikipedia.org/w/index.php?title=Comparison_of_programming_languages_(basic_instructions)&oldid=359780619"