pasar.pts-ptn.net
17 Hours Information Services
Tel/Fax : 021-8762002, 8762003, 8762004, 87912360
Mobile/SMS : 081 1110 4824 27, 0812 9526 2009, 08523 1234 000, 0815 145 78119
WhatsApp : 0817 0816 486, 0812 9526 2009, 0815 145 78119
email : _ Contact Us _ _ please click
Comparison of programming languages (basic instructions) 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 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 orNSInteger unsigned int orNSUInteger 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.xN/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 5N/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 ornativeint 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 orIntInf.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 short s and long s can be usefully prefixed to short int and long int . The actually size of the short int , int and long int is available as constants short max int , max int and long max int etc.^b Commonly used for characters.^c The ALGOL 68, C and C++ languages do not specify the exact width of the integer types "short", "int", "long", and (C99, C++11) "long long", so they are implementation-dependent. In C and C++ "short", "long", and "long long" types are required to be at least 16, 32, and 64 bits wide, respectively, but can be more. The "int" type is required to be at least as wide as "short" and at most as wide as "long", and is typically the width of the word size on the processor of the machine (i.e. on a 32-bit machine it is often 32 bits wide; on 64-bit machines it is 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 short s and long s can be usefully prefixed to short real and long real . The actually size of the short real , real and long real is available as constants short max real , max real and long max real etc. With the constants short small real , small real and long small real available for each type's machine epsilon.^b declarations of single precision often are not honored^c The value of "n" is provided by the SELECTED_REAL_KIND[ 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 nameitem1 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 ...> orenum 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 orSystem.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 ] ...typevector.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] orarray[ first1 .. last1 , first2 .. last2 , ...] of type [c]
N/A N/A Object Pascal (Delphi) array of typearray of array ... of typeVisual Basic Visual Basic .NET System.Collections.ArrayList orSystem.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 orSystem.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 expressionALGOL 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 nameDim name As type ...
End Structure Python N/A [a] «( »val1 , val2 , val3 , ... «) » N/A S-Lang struct { name [=value], ...} Fortran TYPE nametype :: 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»; orvar name = value; const type name = value; orreadonly type name = value; using synonym = type; D type name «= initial_value»; orauto name = value; const type name = value; orimmutable 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_valueconst name «type» = initial_valuetype synonym typeCommon 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 typeConst name As type = value Visual Basic .NET Dim name As type«= initial_value»Imports synonym = typePython name = initial_value N/A synonym = type[b] S-Lang name = initial_value; typedef struct {...} typenameFortran 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 ::= typeRuby 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» = valuetype synonym = typeF# let mutable name «: type» = valueStandard ML val name «: type ref » = ref value[d] val name «: type» = valueHaskell «name:: type; » name = value type Synonym = typeForth VARIABLE name (in some systems use value VARIABLE name instead)value CONSTANT name
^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.
if else if select case conditional expression Ada if condition then statements
«else statements»
end if if condition then statements
elsif condition then statements
... «else statements»
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} » orswitch { case condition: instructions ... «default: instructions»
} switch variable { case case1: instructions ... «default: instructions»
} Perl if ( condition) { instructions} «else { instructions} » orunless ( notcondition) { instructions} «else { instructions} »if ( condition) { instructions} elsif ( condition) { instructions} ... «else { instructions} » orunless ( 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} » orunless notcondition { instructions} if condition { instructions} elsif condition { instructions} ... «else { instructions} given variable { when case1 { instructions } ... «default { instructions } »
} condition ?? valueIfTrue !! valueIfFalse Ruby if conditioninstructions
«else instructions»
if conditioninstructions
elsif conditioninstructions
... «else instructions»
end case variablewhen case1instructions
... «else instructions»
end condition ? valueIfTrue : valueIfFalse Smalltalk condition ifTrue: trueBlock
«ifFalse: falseBlock»
end condition ifTrue: trueBlockifFalse: falseBlock Common Lisp (when conditioninstructions)
or(unless conditioninstructions)
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 begin instructions
end »[c] if condition then begin instructions
end else if condition then begin instructions
end ... «else begin instructions
end »[c] case variable of case1: instructions ... «else: instructions»
end [c] Visual Basic If condition Then instructions
«Else instructions»
End If If condition Then instructions
ElseIf condition Then instructions
... «Else instructions»
End If Select Case variableCase case1instructions
... «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 ↹ instructionselif 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
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 instructionsENDCASE 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 valueIfFalseF# if condition then Tab ↹ instructions «else Tab ↹ instructions»if condition then Tab ↹ instructionselif 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 orwhen condition (do instructions) orunless 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 } orfor each (var item in set) { instructions } (JS 1.6+)PHP foreach (range( first, last-1) as $i) { instructions } orfor ($i = first; $i <= last; $i++) { instructions } foreach ( set as item) { instructions } orforeach ( 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 } oruntil ( notcondition) { instructions } do { instructions } while ( condition) ordo { instructions } until ( notcondition) for «each » «$i » (0 .. N-1) { instructions } orfor ($i = first; $i <= last; $i++) { instructions } for «each » «$item» ( set) { instructions } Perl 6 while condition { instructions } oruntil notcondition { instructions } repeat { instructions } while condition orrepeat { instructions } until notconditionfor first.. last -> $i { instructions } orloop ($i = first; $i <= last; $i++) { instructions } for set« -> $item» { instructions } Ruby while conditioninstructions
end oruntil notconditioninstructions
end begin instructions
end while condition orbegin instructions
end until notconditionfor i in first... lastinstructions
end or first.upto( last-1) { |i| instructions } for item in setinstructions
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 conditioninstructions
Loop orDo Until notconditioninstructions
Loop Do instructions
Loop While condition orDo instructions
Loop Until notconditionFor i = first To last «Step 1 »instructions
Next i For Each item In setinstructions
Next itemVisual Basic .NET For i «As type» = first To last «Step 1 »instructions
Next i [a] For Each item As type In setinstructions
Next itemPython 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, lastinstructions
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) arrayList.iter (fun item -> instructions) listF# while condition do Tab ↹ instructionsN/A for i = first to last-1 do Tab ↹ instructionsfor item in set do Tab ↹ instructions orSeq.iter (fun item -> instructions) setStandard ML while condition do ( instructions ) N/A Array.app (fn item => instructions) arrayapp (fn item => instructions) listHaskell (GHC) N/A 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.
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 exceptionbegin instructions
rescue exceptioninstructions
... «else instructions»
«ensure instructions»
end Smalltalk exception raise instructionBlock on: exception do: handlerBlock assert: conditionBlockCommon 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 (R6 RS) (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 ERRORNUMBERWith 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 Propertyhttps://sites.google.com/site/truetryforvisualbasic/
Debug.Assert conditionVisual Basic .NET Throw exceptionTry instructions
Catch «exception» «When condition»instructions
... «Finally instructions»
End Try Debug.Assert( condition) Python raise exceptiontry: Tab ↹ instructionsexcept «exception»: Tab ↹ instructions ... «else: Tab ↹ instructions» «finally: Tab ↹ instructions»assert conditionFortran N/A Forth code THROW xt CATCH ( code or 0 ) N/A OCaml raise exceptiontry expression with pattern -> expression ...assert conditionF# try expression with pattern -> expression ... ortry expression finally expressionStandard ML raise exception «arg»expression handle pattern => expression ... Haskell (GHC) throw exceptionor throwError expressioncatch tryExpression catchExpressionor catchError tryExpression catchExpressionassert 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 blockN/A label: GoTo labelVisual Basic .NET Continue blockPython break continue N/A yield valueRPG IV LEAVE; ITER; S-Lang break; continue; Fortran EXIT CYCLE label[b] GOTO labelN/A Ruby break next Windows PowerShell break « label»continue OCaml N/A 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.
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 } orstatic int Main( «string[] args ») { instructions } Java public static void main(String[] args) { instructions } orpublic static void main(String... args) { instructions } D int main( «char[][] args ») { instructions} orint main( «string[] args ») { instructions} orvoid main( «char[][] args ») { instructions} orvoid main( «string[] args ») { instructions} JavaScript function foo( «parameters») { instructions } orvar foo = function ( «parameters») { instructions } orvar 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] «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 typeinstructionsFoo = value
End Function Sub Main() instructions
End Sub Visual Basic .NET Function Foo( «parameters») As typeinstructionsReturn value
End Function Sub Main( «ByVal CmdArgs() As String ») instructions
End Sub orFunction Main( «ByVal CmdArgs() As String ») As Integer instructions
End Function Python foo( «parameters») def foo( «parameters»): Tab ↹ instructionsdef foo( «parameters»): Tab ↹ instructionsTab ↹ return valueN/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 maininstructions
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 }; orfunction foo { «param( parameters) » instructions } function foo «( parameters) » { instructions … return value }; orfunction foo { «param( parameters) » instructions … return value } OCaml foo parameterslet «rec » foo parameters = instructionslet «rec » foo parameters = instructions... return_valueF# [<EntryPoint>] let main args = instructionsStandard ML fun foo parameters = ( instructions ) fun foo parameters = ( instructions... return_value ) Haskell foo parameters = do Tab ↹ instructionsfoo parameters = return_value orfoo parameters = do Tab ↹ instructionsTab ↹ return value«main :: IO () »main = do instructions Eiffel foo ( «parameters») foo ( «parameters») require preconditions
do instructions
ensure postconditions
end foo ( «parameters») : typerequire 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]
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 formatsWith 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)); orgetf(proxy, ($dddd$, ivar));
getf(proxy, ($g$, livar)); orgetf(proxy, ($8d$, livar));
getf(proxy, ($g$, rvar)); orgetf(proxy, ($8d.4dE2d$, rvar));
putf(proxy, ($g$, ival)); orputf(proxy, ($4d$, ival));
putf(proxy, ($g(width, places, exp)$, rval)); orputf(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) numberWRITE( string, format) numberPHP 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 stringlet string = string_of_int integerlet string = string_of_float floatF# let integer = int stringlet integer = int64 stringlet float = float stringlet string = string numberStandard ML val integer = Int.fromString string val float = Real.fromString stringval string = Int.toString integerval string = Real.toString floatHaskell (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)); orgetf(stand in, ( $format$, x)); printf (( $format$, x)); orputf(stand out, ( $format$, x)); putf(stand error, ( $format$, x)); [a] C (C99) scanf ( format, & x); orfscanf (stdin, format, & x); [b] printf ( format, x); orfprintf (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); orConsole.WriteLine( «format, »x); Console.Error.Write( «format, »x); orConsole.Error.WriteLine( «format, »x); D x = std.stdio.readln() std.stdio.write( x) orstd.stdio.writeln( x) orstd.stdio.writef( format, x) orstd.stdio.writefln( format, x) stderr.write( x) orstderr.writeln( x) orstd.stdio.writef(stderr, format, x) orstd.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); orSystem.out.printf ( format, x); orSystem.out.println( x); System.err.print( x); orSystem.err.printf ( format, x); orSystem.err.println( x); Go fmt.Scan(& x) orfmt.Scanf ( format, & x) or x = bufio.NewReader(os.Stdin).ReadString('\n') fmt.Println( x) orfmt.Printf ( format, x) fmt.Fprintln(os.Stderr, x) orfmt.Fprintf (os.Stderr, format, x) JavaScriptWeb Browser implementation document.write( x) JavaScriptActive Server Pages Response.Write( x) JavaScriptWindows Script Host x = WScript.StdIn.Read( chars) or x = WScript.StdIn.ReadLine() WScript.Echo( x) orWScript.StdOut.Write( x) orWScript.StdOut.WriteLine( x) WScript.StdErr.Write( x) orWScript.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 (R6 RS) (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); orreadln( x); write( x); orwriteln( x); N/A Visual Basic Input « prompt, » xPrint x or? xVisual Basic .NET x = Console.Read() or x = Console.ReadLine() Console.Write( «format, »x) orConsole.WriteLine( «format, »x) Console.Error.Write( «format, »x) orConsole.Error.WriteLine( «format, »x) Python 2.x x = raw_input( «prompt») print x orsys.stdout.write( x) print >> sys.stderr, x orsys.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; orecho x; orprintf ( format, x); fprintf (STDERR, format, x); Perl $x = <>; or $x = <STDIN>; print x; orprintf format, x; print STDERR x; orprintf 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 orprintf ( 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; orWrite-Output x; orecho x Write-Error xOCaml let x = read_int () orlet str = read_line () orScanf.scanf format (fun x ... -> ...) print_int x orprint_endline str orPrintf.printf format x ...prerr_int x orprerr_endline str orPrintf.eprintf format x ...F# let x = System.Console.ReadLine() printf format x ... orprintfn format x ...eprintf format x ... oreprintfn format x ...Standard ML val str = TextIO.inputLIne TextIO.stdIn print strTextIO.output (TextIO.stdErr, str) Haskell (GHC) x <- readLn or str <- getLine print x orputStrLn strhPrint stderr x orhPutStrLn 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 JavaScriptWindows 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 (R6 RS) (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().Location Python sys.argv[ n] len(sys.argv) first argument S-Lang __argv[ n] __argc first argument Fortran DO i = 1, argcCALL 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); orexecv ( path, arglist); C++ Objective-C [NSTask launchedTaskWithLaunchPath:(NSString *) path arguments:(NSArray *) arguments]; C# System.Diagnostics.Process.Start( path, argstring); F# Go exec.Run( path, argv, envv, dir, exec.DevNull, exec.DevNull, exec.DevNull) os.Exec( path, argv, envv) Visual Basic Interaction.Shell( command «, WindowStyle» «, isWaitOnReturn») Visual Basic .NET Microsoft.VisualBasic.Interaction.Shell( command «, WindowStyle» «, isWaitOnReturn») System.Diagnostics.Process.Start( path, argstring) D std.process.system(" command"); std.process.execv( path, arglist); Java Runtime.exec( command); ornew ProcessBuilder( command).start(); JavaScriptWindows 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 orUnix.execve prog args envStandard ML OS.Process.system commandUnix.execute ( path, args) Posix.Process.exec ( path, args) Haskell (GHC) System.system commandSystem.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` orexec( command) orpassthru( command) Python os.system( command) orsubprocess.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
Tags: Comparison of programming languages (basic instructions), Computer Informatics, 464, Comparison of programming languages (basic instructions) Programming language comparisons General comparison Basic syntax Basic instructions Arrays Associative arrays String operations String functions List comprehension Object oriented programming Object oriented constructors Database access Evaluation strategy List of, Hello World, programs ALGOL 58's influence on ALGOL 60 ALGOL 60: C, Comparison of programming languages (basic instructions), English, Instruction Examples, Tutorials, Reference, Books, Guide pasar, pts-ptn.net
Special Info Education PTS Main & Selected Bachelor, S2, Diploma (D3) Organizer