Comparaison des langages de programmation (instructions de base) - Comparison of programming languages (basic instructions)

const (
  item1 = iota
  item2
  ...
)

enum name { item1« = value», item2« = value», ... }

Enum name
  item1 «= value»
  item2 «= value»
  ...
End Enum

from enum import Enum
class Name(Enum):
  item1 = value
  item2 = value
  ...

object name extends Enumeration {
  val item1, item2, ... = Value
}

const type: name is new enum
  item1,
  item2,
  ...
end enum;

ou alors
array[first1..last1, first2..last2, ...] of type

type name is «abstract» «tagged» «limited» [record
  field1 : type;
  field2 : type;
  ...
end record | null record]

type name (variation : discrete_type) is record
  case variation is
    when choice_list1 =>
      fieldname1 : type;
      ...
    when choice_list2 =>
      fieldname2 : type;
      ...
    ...
  end case;
end record

struct {
  «name» type
  ...
}

struct name {
  var name «: type»
  ...
}

record
  name: type;
  ...
end

record
  case type of
  value: (types);
  ...
end

Structure name
  Dim name As type
  ...
End Structure

TYPE name
  type :: name
  ...
END TYPE

abstract class name
  case class Foo(«parameters») extends name
  case class Bar(«parameters») extends name
  ...

ou alors

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

ou combinaison de classes de cas et d'objets de cas

level-number name type clauses.
  level-number+n name type clauses.
  ...

Les constantes utilisent la même syntaxe et :

• utiliser Constau lieu deDim
• avoir une restriction à certains types primitifs seulement

Const name1 «As type» = value, name2 «As type» = value, ...

Sachant qu'il existe des suffixes d'identifiants ("modificateurs") :

• type_character, disponible comme alternative à une Asclause pour certains types de données primitifs ;
• nullable_specifier; et
• array_specifier;

et cela

• a modified_identifierest de la forme identifier«type_character»«nullable_specifier»«array_specifier»;
• a modified_identifier_listest une liste séparée par des virgules de deux occurrences ou plus de modified_identifier; et
• a declarator_listest une liste de déclarateurs séparés par des virgules, qui peut être de la forme
  • identifier As object_creation_expression (déclarateur d'initialiseur d'objet) ,
  • modified_identifier« As non_array_type«array_rank_specifier»»« = initial_value» (déclarant unique) , ou
  • modified_identifier_list« As «non_array_type««array_rank_specifier»» (déclarateur multiple);

les déclarations de déclaration valides sont de la forme

Dim declarator_list,

où, à des fins d'analyse sémantique, pour convertir le declarator_listen une liste de déclarateurs uniques :

Les Asclauses de chaque déclarant multiple sont réparties sur sonmodified_identifier_list

Le As New type...de chaque déclarateur d'initialiseur d'objet est remplacé parAs type = New type...

et pour lequel, pour chaque identifier,

• a type_characteret la Asclause n'apparaissent pas toutes les deux ;
• si une Asclause est présente,
  • un array_rank_specifiern'apparaît pas à la fois comme une modification de l'identifiant et sur le type de la Asclause ;
• an unmodified_typepeut être déterminé, par la règle selon laquelle,
  • si une clause type_characterou Asest présente,
    • unmodified_type est celui spécifié par une telle construction,
  • et que sinon,
    • soit Option Inferdoit être activé et identifierdoit avoir un initialiseur, auquel cas unmodified_typeest celui de l'initialiseur, ou
    • Option Strictdoit être éteint, auquel cas unmodified_typeest Object;
• son final_typeest son unmodified_typepréfixé avant ses modificateurs;
• son final_typeest un type valide; et
• si un initial_valueest présent,
  • soit Option Strictest activé et initial_valuea une conversion qui s'élargit vers final_type, ou
  • Option Strictest désactivé et initial_valuea une conversion de rétrécissement en final_type.

Si Option Explicitest désactivé, les variables ne nécessitent pas de déclaration explicite ; ils sont déclarés implicitement lorsqu'ils sont utilisés :

name = initial_value

if condition then
  statements
«else
  statements»
end if

if condition1 then
  statements
elsif condition2 then
  statements
...
«else
  statements»
end if

case expression is
  when value_list1 => statements
  when value_list2 => statements
  ...
  «when others => statements»
end case

(if condition1 then
  expression1
«elsif condition2 then
  expression2»
...
else
  expressionn
 )

ou alors

 (case expression is
   when value_list1 => expression1
   when value_list2 => expression2
   ...
   «when others => expressionn»
)

if condition then
  statements
«else
  statements»
end if

si condition ₁ alors

  statements
elsif condition2 then
  statements
...
«else
  statements»
end if

case expression of
  when set1 : statements
  ...
  «otherwise: statements»
end case

if condition then
  statements
«else
  statements»
end

if condition1 then
  statements
elsif condition2 then
  statements
...
«else
  statements»
end

case expression of
  caseLabelList : statements |
  ...
  «else statements»
end

( condition | valueIfTrue | valueIfFalse )

( condition | statements «| statements» )

( condition | statements |: condition |  statements )

( variable | statements,... «| statements» )

:If condition
  instructions
«:Else
  instructions»
:EndIf

:If condition
  instructions
:ElseIf condition
  instructions
...
«:Else
  instructions»
:EndIf

:Select expression
  :Case case1
    instructions
  ...
  «:Else
    instructions»
:EndSelect

• Objectif c
• C++ (LIST)
• ré
• Java
• JavaScript
• PHP

if (condition) instructions
«else instructions»

instructions peut être une seule instruction ou un bloc sous la forme de : { statements }

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

ou alors

if (condition) instructions
else { if (condition) instructions }

switch (variable) {
  case case1: instructions «; break;»
  ...
  «default: instructions»
}

if (condition) instructions
«else instructions»

instructions peut être une seule instruction ou un bloc sous la forme de : { statements }

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

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

Tous les cas non vides doivent se terminer par une instruction breakou goto case(c'est-à-dire qu'ils ne sont pas autorisés à passer au cas suivant). L' defaultaffaire n'est pas obligée de passer en dernier.

if (condition) instruction
«else instructions»

if (condition) { instructions }
elseif (condition) { instructions }
...
«else { instructions }»

switch (variable) { case1{instructions «break;» } ... «default { instructions }»}

if condition {instructions}
«else {instructions}»

if condition {instructions}
else if condition {instructions}
...
«else {instructions}»

ou alors

switch {
  case condition: instructions
  ...
  «default: instructions»
}

switch variable {
  case case1: instructions
  ...
  «default: instructions»
}

if condition {instructions}
«else {instructions}»

if condition {instructions}
else if condition {instructions}
...
«else {instructions}»

switch variable {
  case case1: instructions
  ...
  «default: instructions»
}

if (condition) {instructions}
«else {instructions}»

ou alors

unless (notcondition) {instructions}
«else {instructions}»

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

ou alors

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

use feature "switch";
...
given (variable) {
  when (case1) { instructions }
  ...
  «default { instructions }»
}

if condition {instructions}
«else {instructions}»

ou alors

unless notcondition {instructions}

if condition {instructions} 
elsif condition {instructions} 
...
«else {instructions}

given variable {
  when case1 { instructions }
  ...
  «default { instructions }»
}

if condition
  instructions
«else
  instructions»

if condition
  instructions
elsif condition
  instructions
...
«else
  instructions»
end

case variable
  when case1
    instructions
  ...
  «else
    instructions»
end

if (condition) {instructions}
«else {instructions}»

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

expression match {
  case pattern1 => expression
  case pattern2 => expression
  ...
  «case _ => expression»
}

condition ifTrue:
  trueBlock
«ifFalse:
  falseBlock»
end

(when condition
  instructions)

ou alors

(unless condition
  instructions)

ou alors

(if condition
  (progn instructions)
  «(progn instructions)»)

(cond (condition1 instructions)
  (condition2 instructions)
  ...
  «(t instructions)»)

(case expression
  (case1 instructions)
  (case2 instructions)
  ...
  «(otherwise instructions)»)

(if test then else)

ou alors

(cond (test1 value1) (test2 value2) ...))

(when condition instructions)

ou alors

(if condition (begin instructions) «(begin instructions)»)

(if condition
  (progn instructions)
  «(progn instructions)»)

(cond (condition1 instructions)
  (condition2 instructions)
  ...
  «(t instructions)»)

(case expression
  (case1 instructions)
  (case2 instructions)
  ...
  «(t instructions)»)

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»

case variable of
  case1: instructions
  ...
  «else: instructions»
end

If condition Then
  instructions
«Else
  instructions»
End If

Monoligne, quand instructionssont : instruction1 : instruction2 : ...

If condition Then instructions «Else instructions»

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

Une seule ligne:

Voir la note sur les langages de type C ; la Elseclause d'une Ifinstruction monoligne peut contenir une autre Ifinstruction monoligne.

Select« Case» variable
  Case case_pattern1
    instructions
  ...
  «Case Else
    instructions»
End Select

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

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

match variable:
Tab ↹ case case1:
Tab ↹Tab ↹ instructions
Tab ↹ case case2:
Tab ↹Tab ↹ instructions

valueIfTrue if condition else valueIfFalse

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

value CASE
  case OF instructions ENDOF
  case OF instructions ENDOF
    default instructions
ENDCASE

match value with 
  pattern1 -> expression
  | pattern2 -> expression
  ...
  «| _ -> expression»

if condition then valueIfTrue else valueIfFalse

Soit sur une seule ligne, soit avec une indentation comme indiqué ci-dessous :

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

Mode de syntaxe verbeuse :

Identique au ML standard (ci-dessous).

Soit sur une seule ligne, soit avec une indentation comme indiqué ci-dessous :

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

Mode de syntaxe verbeuse :

Identique au ML standard (ci-dessous).

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»

if condition then expression else expression

ou alors

when condition (do instructions)

ou alors

unless notcondition (do instructions)

result | condition = expression
  | condition = expression
  | otherwise = expression

case value of {
  pattern1 -> expression;
  pattern2 -> expression;
  ...
  «_ -> expression»
}

if condition-command; then
  expression
«else
  expression»
fi

if condition-command; then
  expression
elif condition-command; then
  expression
«else
  expression»
fi

case "$variable" in
  "$condition1" )
    command...
  "$condition2" )
    command...
esac

if condition then expression «else expression»

ou alors

if condition
  expression
«else
  expression»

ou alors

expression if condition

ou alors

unless condition
  expression
«else
  expression»

ou alors

expression unless condition

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

ou alors

if condition
  expression
else if condition
  expression
«else
  expression»

ou alors

unless condition
  expression
else unless condition
  expression
«else
  expression»

switch expression
  when condition then expression
  else expression

ou alors

switch expression
  when condition
    expression
  «else
    expression»

IF condition «THEN»
  expression
«ELSE
  expression».

EVALUATE expression «ALSO expression...»
  WHEN case-or-condition «ALSO case-or-condition...»
    expression
  ...
  «WHEN OTHER
    expression»
END-EVALUATE

if condition {
  expression 
}« else {
  expression 
}»

if condition {
  expression 
} else if condition {
  expression 
}« else {
  expression 
}»

match variable {
   pattern1 => expression,
   pattern2 => expression,
   pattern3 => expression,
  «_ => expression»
}

Toutes les conditions sont des expressions

while condition loop
  statements
end loop

loop
  statements
  exit when not condition
end loop

for index in «reverse» [first .. last | discrete_type] loop
  statements
end loop

for item of «reverse» iterator loop
  statements
end loop

ou alors

(for [all | some] [in | of] [first .. last | discrete_type | iterator] => predicate)

«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

:While condition
  statements
:EndWhile

:Repeat
  statements
:Until condition

:For var«s» :In list
  statements
:EndFor

:For var«s» :InEach list
  statements
:EndFor

while (condition) instructions

do instructions while (condition);

for («type» i = first; i <= last; i++) instructions

for (type item in set) instructions

«std::»for_each(start, end, function)

Depuis C++11 :

for (type item : set) instructions

foreach (type item in set) instructions

for (type item : set) instructions

for (var i = first; i <= last; i++) instructions

Depuis EcmaScript 2015 :

for (var item of set) instructions

foreach (range(first, last) as $i) instructions

ou alors

for ($i = first; $i <= last; $i++) instructions

foreach (set as item) instructions

ou alors

foreach (set as key => item) instructions

for ($i = first; $i -le last; $i++) instructions

foreach (item in set) instructions

foreach (i; first ... last) instructions

foreach («type» item; set) instructions

for condition { instructions }

for i := first; i <= last; i++ { instructions }

for key, item := range set { instructions }

while condition { instructions }

repeat { instructions } while condition

1 fois:

do { instructions } while condition

for i = first ... last { instructions }

ou alors

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

ou alors

for var i = first; i <= last; i++ { instructions }

for item in set { instructions }

while (condition) { instructions }

ou alors

until (notcondition) { instructions }

do { instructions } while ( condition ) ou

do { instructions } until (notcondition)

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

ou alors

for ($i = first; $i <= last; $i++) { instructions }

for«each» «$item» (set) { instructions }

while condition { instructions }

ou alors

until notcondition { instructions }

repeat { instructions } while condition

ou alors

repeat { instructions } until notcondition

for  first..last -> $i  { instructions }

ou alors

loop ($i = first; $i <=last; $i++) { instructions }

for set« -> $item»  { instructions }

while condition
  instructions
end

ou alors

until notcondition
  instructions
end

begin
  instructions
end while condition

ou alors

begin
  instructions
end until notcondition

for i in first..last
  instructions
end

ou alors

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

ou alors

first.upto(last) { ||i|| instructions }

for item in set
  instructions
end

ou alors

set.each { |item| instructions }

while condition ;do
  instructions
done

ou alors

until notcondition ;do
  instructions
done

for ((i = first; i <= last; ++i)) ; do
  instructions
done

for item in set ;do
  instructions
done

while (condition) { instructions }

do { instructions } while (condition)

for (i <- first to last «by 1») { instructions }

ou alors

first to last «by 1» foreach (i => { instructions })

for (item <- set) { instructions }

ou alors

set foreach (item => { instructions })

conditionBlock whileTrue:
  loopBlock

loopBlock doWhile:
  conditionBlock

first to: last do:
  loopBlock

collection do:
  loopBlock

(loop
  while condition
  do
  instructions)

ou alors

(do () (notcondition)
  instructions)

(loop
  do
  instructions
  while condition)

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

ou alors

(dotimes (i N)
  instructions)

ou alors

(do ((i first (1+ i))) ((>=i last))
  instructions)

(loop
  for item in list
  do
  instructions)

ou alors

(loop
  for item across vector
  do
  instructions)

ou alors

(dolist (item list)
  instructions)

ou alors

(mapc function list)

ou alors

(map 'type function sequence)

(do () (notcondition) instructions)

ou alors

(let loop () (if condition (begin instructions (loop))))

(let loop () (instructions (if condition (loop))))

(do ((i first (+ i 1))) ((>= i last)) instructions)

ou alors

(let loop ((i first)) (if (< i last) (begin instructions (loop (+ i 1)))))

(for-each (lambda (item) instructions) list)

(while condition instructions)

(tagbody loop instructions (if condition (go loop))

(for ((i first (+ i 1))) ((>= i last)) instructions)

(mapc (lambda (item) instructions) list)

while condition do begin
  instructions
end

repeat
  instructions
until notcondition;

for i := first «step 1» to last do begin
  instructions
end;

for item in set do instructions

Do While condition
  instructions
Loop

ou alors

Do Until notcondition
  instructions
Loop

ou alors

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

Do
  instructions
Loop While condition

ou alors

Do
  instructions
Loop Until notcondition

For i = first To last «Step 1»
  instructions
Next i

For Each item In set
  instructions
Next item

For i« As type» = first To last« Step 1»
  instructions
Next« i»

For Each item« As type» In set
  instructions
Next« item»

While condition
  instructions
Wend

Do Until notcondition
  instructions
Loop

ou alors

Do
  instructions
Loop Until notcondition

while condition :
Tab ↹ instructions
«else:
Tab ↹ instructions»

for i in range(first, last+1):
Tab ↹ instructions
«else:
Tab ↹ instructions»

Python 2.x :

for i in xrange(first, last+1):
Tab ↹ instructions
«else:
Tab ↹instructions»

for item in set:
Tab ↹ instructions
«else:
Tab ↹ instructions»

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»

DO WHILE (condition)
  instructions
ENDDO

DO
  instructions
   IF (condition) EXIT
ENDDO

DO I = first,last
  instructions
ENDDO

BEGIN « instructions » condition WHILE instructions REPEAT

BEGIN  instructions condition UNTIL

limit start DO instructions LOOP

while condition do instructions done

for i = first to last do instructions done

Array.iter (fun item -> instructions) array

ou alors

List.iter (fun item -> instructions) list

while condition do
Tab ↹ instructions

for i = first to last do
Tab ↹ instructions

for item in set do
Tab ↹ instructions

ou alors

Seq.iter (fun item -> instructions) set

while condition do ( instructions )

Array.app (fn item => instructions) array

ou alors

app (fn item => instructions) list

Control.Monad.forM_ [first..last] (\i -> do instructions)

Control.Monad.forM_ list (\item -> do instructions)

from
  setup
until
  condition
loop
  instructions
end

while condition
  expression

ou alors

expression while condition

ou alors

while condition then expression

ou alors

until condition
  expression

ou alors

expression until condition

ou alors

until expression then condition

for i in [first..last]
  expression

ou alors

for i in [first..last] then expression

ou alors

expression for i in [first..last]

for item in set
  expression

ou alors

for item in set then expression

ou alors

expression for item in set

PERFORM procedure-1 «THROUGH procedure-2» ««WITH» TEST BEFORE» UNTIL condition

ou alors

PERFORM ««WITH» TEST BEFORE» UNTIL condition
  expression
END-PERFORM

PERFORM procedure-1 «THROUGH procedure-2» «WITH» TEST AFTER UNTIL condition

ou alors

PERFORM «WITH» TEST AFTER UNTIL condition
  expression
END-PERFORM

PERFORM procedure-1 «THROUGH procedure-2» VARYING i FROM first BY increment UNTIL i > last

ou alors

PERFORM VARYING i FROM first BY increment UNTIL i > last
  expression
END-PERFORM

while condition {
  expression
}

loop {
  expression
  if condition {
      break;
  }
}

for i in first..last+1 {
  expression
}

ou alors

for i in first..=last {
  expression
} 

for item in set {
  expression
}

ou alors

set.into_iter().for_each(|item| expression);

System.Diagnostics.Trace.Assert(condition);

Error errorcode

System.Diagnostics.Trace.Assert(condition)

( Rappel )

Return

void foo(«parameters») => statement;

void foo(«parameters») => expression;

Peut à la place revenir int.

(à partir de C# 7.1 :) Peut retourner Taskou Task<int>, et si c'est le cas, peut être async.

instructions
Return value

La Asclause n'est pas requise si Option Strictest désactivé. Un caractère type peut être utilisé à la place de la Asclause.

Si le contrôle quitte la fonction sans qu'une valeur de retour ait été explicitement spécifiée, la fonction renvoie la valeur par défaut pour le type de retour.

instructions