POUR (POSITION=VALEUR ; TANT QUE POSITION INFÉRIEUR A VALEUR MAX ; ACTION SUR POSITION) {
	// Instructions à exécuter
	// A chaque passage dans la boucle, POSITION aura une valeur différente selon que l'on choisisse
	// de l'incrémenter ou décrémenter
	// Pour sortir prématurément d'une boucle
	break ;
}

POUR (POSITION=VALEUR ; TANT QUE POSITION INFÉRIEUR A VALEUR MAX ; ACTION SUR POSITION) {
	// Instructions à exécuter
	// A chaque passage dans la boucle, POSITION aura une valeur différente selon que l'on choisisse
	// de l'incrémenter ou décrémenter
	// Pour sortir prématurément d'une boucle
	break ;
}

#define <stdio.h>
#define <stdlib.h>
 
int main(void) {
        /* Définition des variables */
        int position;
        int max=8;
        /* Définition du tableau personnes */
        char personnes[8][16]={
                "Marie", "Marc", "Antoine", "Jean", "Eric", "Simone",
                "Pierre", "Martine"
        };
        /* Définition du tableau villes */
        char villes[8][16]={
                "Lyon", "Grenoble", "Paris", "Beauvais", "Bordeaux",
                "Valence", "Nantes", "Auxerre"
        };
 
        /* Traitement des tableaux avec une boucle for */
        for (position=0; position < max; position++) {
                printf("%s travaille à %s\n", personnes[position], villes[position]);
        }
        return EXIT_SUCCESS;
}

#define <stdio.h>
#define <stdlib.h>
 
int main(void) {
        /* Définition des variables */
        int position;
        int max=8;
        /* Définition du tableau personnes */
        char personnes[8][16]={
                "Marie", "Marc", "Antoine", "Jean", "Eric", "Simone",
                "Pierre", "Martine"
        };
        /* Définition du tableau villes */
        char villes[8][16]={
                "Lyon", "Grenoble", "Paris", "Beauvais", "Bordeaux",
                "Valence", "Nantes", "Auxerre"
        };
 
        /* Traitement des tableaux avec une boucle for */
        for (position=0; position < max; position++) {
                printf("%s travaille à %s\n", personnes[position], villes[position]);
        }
        return EXIT_SUCCESS;
}

var personnes=[ 'Marie', 'Marc', 'Antoine', 'Jean', 'Eric', 'Simone', 'Pierre', 'Martine' ] ;
var villes=[ 'Lyon', 'Grenoble', 'Paris', 'Beauvais', 'Bordeaux', 'Valence', 'Nantes', 'Auxerre' ] ;
var pos ;
// Nombres d'éléments dans le tableau personnes
max=personnes.length ;
// Parcours du tableau avec la boucle for
for (pos=0 ; pos < max ; pos++) {
  console.log(personnes[pos] + ' travaille à ' + villes[pos]) ;
}

var personnes=[ 'Marie', 'Marc', 'Antoine', 'Jean', 'Eric', 'Simone', 'Pierre', 'Martine' ] ;
var villes=[ 'Lyon', 'Grenoble', 'Paris', 'Beauvais', 'Bordeaux', 'Valence', 'Nantes', 'Auxerre' ] ;
var pos ;
// Nombres d'éléments dans le tableau personnes
max=personnes.length ;
// Parcours du tableau avec la boucle for
for (pos=0 ; pos < max ; pos++) {
  console.log(personnes[pos] + ' travaille à ' + villes[pos]) ;
}

<?php
$personnes=array('Marie', 'Marc', 'Antoine', 'Jean', 'Eric', 'Simone', 'Pierre', 'Martine') ;
$villes=array('Lyon', 'Grenoble', 'Paris', 'Beauvais', 'Bordeaux', 'Valence', 'Nantes', 'Auxerre') ;
// Nombre d'éléments dans le tableau personnes
$max=count($personnes) ;
// Parcours du tableau avec la boucle for
for ($pos=0 ; $pos < $max ; $pos++) {
  echo $personnes[$pos]." travaille à ".$villes[$pos]."<br/>" ;
}
 
// Méthode alternative pour parcourir un tableau en PHP
$pos=0 ;
// A chaque passage, $prenom contiendra le nom de l'élément du tableau puis passera au suivant à la fin de la boucle
foreach ($personnes AS $prenom) {
  echo $prenom." travaille à ".$villes[$pos]
  $pos++ ;
}

<?php
$personnes=array('Marie', 'Marc', 'Antoine', 'Jean', 'Eric', 'Simone', 'Pierre', 'Martine') ;
$villes=array('Lyon', 'Grenoble', 'Paris', 'Beauvais', 'Bordeaux', 'Valence', 'Nantes', 'Auxerre') ;
// Nombre d'éléments dans le tableau personnes
$max=count($personnes) ;
// Parcours du tableau avec la boucle for
for ($pos=0 ; $pos < $max ; $pos++) {
  echo $personnes[$pos]." travaille à ".$villes[$pos]."<br/>" ;
}
 
// Méthode alternative pour parcourir un tableau en PHP
$pos=0 ;
// A chaque passage, $prenom contiendra le nom de l'élément du tableau puis passera au suivant à la fin de la boucle
foreach ($personnes AS $prenom) {
  echo $prenom." travaille à ".$villes[$pos]
  $pos++ ;
}

#!/usr/bin/perl
 
use strict;
 
# Définition des tableaux
my @personnes=('Marie', 'Marc', 'Antoine', 'Jean', 'Eric', 'Simone', 'Pierre', 'Martine');
my @villes=('Lyon', 'Grenoble', 'Paris', 'Beauvais', 'Bordeaux', 'Valence', 'Nantes', 'Auxerre');
 
my $pos;
 
# Parcours des tableaux
for ($pos=0; $pos < scalar(@personnes); $pos++) {
        print $personnes[$pos]." travaille à ".$villes[$pos]."\n";
}
 
# Méthode alternative pour un tableau en Perl
$pos=0;
foreach (@personnes) {
        print $_." travaille à ".$villes[$pos]."\n";
        $pos++;
}

#!/usr/bin/perl
 
use strict;
 
# Définition des tableaux
my @personnes=('Marie', 'Marc', 'Antoine', 'Jean', 'Eric', 'Simone', 'Pierre', 'Martine');
my @villes=('Lyon', 'Grenoble', 'Paris', 'Beauvais', 'Bordeaux', 'Valence', 'Nantes', 'Auxerre');
 
my $pos;
 
# Parcours des tableaux
for ($pos=0; $pos < scalar(@personnes); $pos++) {
        print $personnes[$pos]." travaille à ".$villes[$pos]."\n";
}
 
# Méthode alternative pour un tableau en Perl
$pos=0;
foreach (@personnes) {
        print $_." travaille à ".$villes[$pos]."\n";
        $pos++;
}

SWITCH ($valeur) {
	CAS '1' :
		// Instructions à exécuter lorsque $valeur est égal à 1
		// Sortie de la structure
		BREAK
	CAS '2' :
	CAS '3' :
	CAS '5' :
		// Instructions à exécuter lorsque $valeur est égal à 2, 3 ou 5
		// Sortie de la structure
		BREAK
	CAS '6' :
		// Instructions à exécuter si $valeur est égal à 6
		// On ne sort pas de la structure, donc on traite aussi le cas de figure suivant
	CASE '9' :
		// Instructions à exécuter si $valeur est égal à 6 ou 9
		// Sortie de la structure
		BREAK
	DEFAULT :
		// Instructions à exécuter pour tous les cas de figure qui n'ont pas été traités précédemment
}

SWITCH ($valeur) {
	CAS '1' :
		// Instructions à exécuter lorsque $valeur est égal à 1
		// Sortie de la structure
		BREAK
	CAS '2' :
	CAS '3' :
	CAS '5' :
		// Instructions à exécuter lorsque $valeur est égal à 2, 3 ou 5
		// Sortie de la structure
		BREAK
	CAS '6' :
		// Instructions à exécuter si $valeur est égal à 6
		// On ne sort pas de la structure, donc on traite aussi le cas de figure suivant
	CASE '9' :
		// Instructions à exécuter si $valeur est égal à 6 ou 9
		// Sortie de la structure
		BREAK
	DEFAULT :
		// Instructions à exécuter pour tous les cas de figure qui n'ont pas été traités précédemment
}

#define <stdio.h>
#define <stdlib.h>
 
#define PERSIL 0 
#define SALADE 1
#define TOMATE 2
#define CAROTTE 3
#define POIVRON 4
 
/* Définition de la fonction de traitement */
void couleur(int legume) {
  switch (legume) {
      case PERSIL :
      case SALADE :
        printf("Couleur : verte\n") ;
        break ;
      case TOMATE :
      case POIVRON :
        printf("Couleur : rouge\n") ;
        break ;
      default :
        printf("Cas de figure non traité\n") ;
    }
  }
}
 
int main(void) {
  couleur(PERSIL) ; /* Affichera : Couleur : verte */
  couleur(POIVRON) ; /* Affichera : Couleur : rouge */
  couleur(CAROTTE) ; /* Affichera : Cas de figure non traité */
 
}

#define <stdio.h>
#define <stdlib.h>
 
#define PERSIL 0 
#define SALADE 1
#define TOMATE 2
#define CAROTTE 3
#define POIVRON 4
 
/* Définition de la fonction de traitement */
void couleur(int legume) {
  switch (legume) {
      case PERSIL :
      case SALADE :
        printf("Couleur : verte\n") ;
        break ;
      case TOMATE :
      case POIVRON :
        printf("Couleur : rouge\n") ;
        break ;
      default :
        printf("Cas de figure non traité\n") ;
    }
  }
}
 
int main(void) {
  couleur(PERSIL) ; /* Affichera : Couleur : verte */
  couleur(POIVRON) ; /* Affichera : Couleur : rouge */
  couleur(CAROTTE) ; /* Affichera : Cas de figure non traité */
 
}

// Définition de la fonction
function couleur(legume) {
  var ret ;
 
  switch (legume) {
    case 'persil' :
    case 'salade' :
      ret='vert' ;
      break ;
    case 'tomate' :
    case 'poivron' :
      ret='rouge' ;
      break ;
    default :
      ret='Cas de figure non traité' ;
  }
  // Retourne le résultat à la fonction appelante
  return ret ;
}
 
// Utilisation de la fonction
console.log(couleur('persil')) ;  // Affichera : vert
console.log(couleur('poivron')) ;  // Affichera : rouge
console.log(couleur('banane')) ;  // Affichera : Cas de figure non traité

// Définition de la fonction
function couleur(legume) {
  var ret ;
 
  switch (legume) {
    case 'persil' :
    case 'salade' :
      ret='vert' ;
      break ;
    case 'tomate' :
    case 'poivron' :
      ret='rouge' ;
      break ;
    default :
      ret='Cas de figure non traité' ;
  }
  // Retourne le résultat à la fonction appelante
  return ret ;
}
 
// Utilisation de la fonction
console.log(couleur('persil')) ;  // Affichera : vert
console.log(couleur('poivron')) ;  // Affichera : rouge
console.log(couleur('banane')) ;  // Affichera : Cas de figure non traité

<?php
// Définition de la fonction
function couleur($legume) {
  $ret='' ;
  switch ($legume) {
    case 'salade' :
    case 'persil' :
      $ret='vert' ;
      break ;
    case 'tomate' :
    case 'poivron' :
      $ret='rouge' ;
      break ;
    default :
      $ret='Cas de figure non traité' ;
  }
}
 
// Utilisation de la fonction
echo "Le persil c'est : ".couleur('persil') ;  // Affichera : Le persil c'est : vert
echo "La tomate c'est : ".couleur('tomate') ;  // Affichera : La tomate c'est : rouge
echo "La banane c'est : ".couleur('banane') ;  // Affichera : La banane c'est : Cas de figure non traité

<?php
// Définition de la fonction
function couleur($legume) {
  $ret='' ;
  switch ($legume) {
    case 'salade' :
    case 'persil' :
      $ret='vert' ;
      break ;
    case 'tomate' :
    case 'poivron' :
      $ret='rouge' ;
      break ;
    default :
      $ret='Cas de figure non traité' ;
  }
}
 
// Utilisation de la fonction
echo "Le persil c'est : ".couleur('persil') ;  // Affichera : Le persil c'est : vert
echo "La tomate c'est : ".couleur('tomate') ;  // Affichera : La tomate c'est : rouge
echo "La banane c'est : ".couleur('banane') ;  // Affichera : La banane c'est : Cas de figure non traité

#!/usr/bin/perl
 
use strict;
# Chargement du module Switch.pm
use Switch;
 
# Définition de la fonction
sub couleur {
        my ($legume)=@_;
        my $ret;
 
        # Utilisation de la structure émulée
        switch ($legume) {
                # Syntaxe pour exécuter les mêmes instructions
                # pour 2 cas de figures différents
                case ['salade', 'persil'] {
                        $ret='vert';
                }
                # Syntaxe pour exécuter les mêmes instructions
                # pour 2 cas de figures différents
                case ['tomate', 'poivron'] {
                        $ret='rouge';
                }
                # Équivalent du mot clé default pour traiter tous les cas de figure qui n'ont pas été 
                # traité par les instructions au dessus
                else {
                        $ret='Cas de figure non traité';
                }
        }
        return $ret;
}
 
print "Une salade c'est: ".couleur('salade')."\n";  # Affichera : Une salade c'est : vert
print "Un poivron c'est: ".couleur('poivron')."\n";  # Affichera : Un poivron c'est : rouge
print "Une banane c'est: ".couleur('banane')."\n";  # Affichera : Une banane c'est : Cas de figure non traité

#!/usr/bin/perl
 
use strict;
# Chargement du module Switch.pm
use Switch;
 
# Définition de la fonction
sub couleur {
        my ($legume)=@_;
        my $ret;
 
        # Utilisation de la structure émulée
        switch ($legume) {
                # Syntaxe pour exécuter les mêmes instructions
                # pour 2 cas de figures différents
                case ['salade', 'persil'] {
                        $ret='vert';
                }
                # Syntaxe pour exécuter les mêmes instructions
                # pour 2 cas de figures différents
                case ['tomate', 'poivron'] {
                        $ret='rouge';
                }
                # Équivalent du mot clé default pour traiter tous les cas de figure qui n'ont pas été 
                # traité par les instructions au dessus
                else {
                        $ret='Cas de figure non traité';
                }
        }
        return $ret;
}
 
print "Une salade c'est: ".couleur('salade')."\n";  # Affichera : Une salade c'est : vert
print "Un poivron c'est: ".couleur('poivron')."\n";  # Affichera : Un poivron c'est : rouge
print "Une banane c'est: ".couleur('banane')."\n";  # Affichera : Une banane c'est : Cas de figure non traité

ma_variable=(condition) ? Valeur si condition vrai:Valeur si condition fausse ;

Cela revient à écrire la structure suivante :
Si (condition est vrai) {
	ma_variable= valeur si condition vrai
}
Sinon {
	ma_variable= valeur si condition fausse
}
// La même en version courte
SI (condition) { ma_variable=valeur } SINON { ma_variable=valeur }

ma_variable=(condition) ? Valeur si condition vrai:Valeur si condition fausse ;

Cela revient à écrire la structure suivante :
Si (condition est vrai) {
	ma_variable= valeur si condition vrai
}
Sinon {
	ma_variable= valeur si condition fausse
}
// La même en version courte
SI (condition) { ma_variable=valeur } SINON { ma_variable=valeur }

#define <stdio.h>
#define <stdlib.h>
 
int main(void) {
  int a=5 ;
  /* Si a est supérieur à 4, alors la valeur de b sera 6, sinon ce sera 2 */
  /* Dans le cas présent la valeur de b sera 6 */
  int b=(a > 4) ? 6:2 ;
}

#define <stdio.h>
#define <stdlib.h>
 
int main(void) {
  int a=5 ;
  /* Si a est supérieur à 4, alors la valeur de b sera 6, sinon ce sera 2 */
  /* Dans le cas présent la valeur de b sera 6 */
  int b=(a > 4) ? 6:2 ;
}

var a=5 ;
var b=(a > 4) ? 'Attention !' :'Tout va bien' ;
console.log(b + ' Valeur = ' + a) ;  // Affichera : Attention ! Valeur = 5
 

var a=5 ;
var b=(a > 4) ? 'Attention !' :'Tout va bien' ;
console.log(b + ' Valeur = ' + a) ;  // Affichera : Attention ! Valeur = 5
 

<?php
$a=4;
b=($a > 4) ? 'Alerte !' :'Ok';
 
echo "$b Valeur = $a";  // Affichera : Ok Valeur = 4

<?php
$a=4;
b=($a > 4) ? 'Alerte !' :'Ok';
 
echo "$b Valeur = $a";  // Affichera : Ok Valeur = 4

#!/usr/bin/perl
 
use strict;
 
my $a=5;
my $b=($a > 4) ? 'Alerte!':'Ok';
 
print $b." Valeur: $a\n";  # Affichera : Alerte! Valeur: 5

#!/usr/bin/perl
 
use strict;
 
my $a=5;
my $b=($a > 4) ? 'Alerte!':'Ok';
 
print $b." Valeur: $a\n";  # Affichera : Alerte! Valeur: 5

// Définition
FONCTION nom_fonction(paramètre_1, paramètre_2, paramètre_x) {
	// Instructions à exécuter et éventuellement valeur à retourner
}

// Utilisation
RESULTAT_1=nom_fonction(val1, val2, valx) ;
RESULTAT_2=nom_fonction(val12, val22, valx2) ;
RESULTAT_Y=nom_fonction(val1y, val2y, valxy) ;

// Définition
FONCTION nom_fonction(paramètre_1, paramètre_2, paramètre_x) {
	// Instructions à exécuter et éventuellement valeur à retourner
}

// Utilisation
RESULTAT_1=nom_fonction(val1, val2, valx) ;
RESULTAT_2=nom_fonction(val12, val22, valx2) ;
RESULTAT_Y=nom_fonction(val1y, val2y, valxy) ;

#define <stdio.h>
#define <stdlib.h>
 
/* En C les paramètres d'une fonction se définissent avec leur type comme les variables */
int voyelles(char *mot) {
  int res=0 ;
  int pos=0 ;
 
  /* Tant que la fin de la chaînes de caractères n'a pas été atteinte */
  while (mot[pos]!='\0') {
    // On parcoure chaque lettre du mot et à chaque voyelle on ajoute 1 à la valeur de res
    if (mot[pos]=='a' || mot[pos]=='e' || mot[pos]=='i' || mot[pos]=='o' || mot[pos]=='u' || mot[pos]=='y') {
      res++ ;
    }
    pos++;
  }
  // Retourne la valeur de res à la fonction appelante
  return res;
}
 
int main(void) {
  printf("azerty contient %d voyelle(s)\n", voyelles("azerty")) ;
   /* Affiche : azerty contient 3 voyelle(s) */
  printf("pierre contient%d voyelle(s)\n", voyelles("pierre")) ;
   /* Affiche : pierre contient 3 voyelle(s) */
  printf("toto contient%d voyelle(s)\n", voyelles("toto")) ;
   /* Affiche : toto contient 2 voyelle(s) */
 
  return EXIT_SUCCESS ;
}
 

#define <stdio.h>
#define <stdlib.h>
 
/* En C les paramètres d'une fonction se définissent avec leur type comme les variables */
int voyelles(char *mot) {
  int res=0 ;
  int pos=0 ;
 
  /* Tant que la fin de la chaînes de caractères n'a pas été atteinte */
  while (mot[pos]!='\0') {
    // On parcoure chaque lettre du mot et à chaque voyelle on ajoute 1 à la valeur de res
    if (mot[pos]=='a' || mot[pos]=='e' || mot[pos]=='i' || mot[pos]=='o' || mot[pos]=='u' || mot[pos]=='y') {
      res++ ;
    }
    pos++;
  }
  // Retourne la valeur de res à la fonction appelante
  return res;
}
 
int main(void) {
  printf("azerty contient %d voyelle(s)\n", voyelles("azerty")) ;
   /* Affiche : azerty contient 3 voyelle(s) */
  printf("pierre contient%d voyelle(s)\n", voyelles("pierre")) ;
   /* Affiche : pierre contient 3 voyelle(s) */
  printf("toto contient%d voyelle(s)\n", voyelles("toto")) ;
   /* Affiche : toto contient 2 voyelle(s) */
 
  return EXIT_SUCCESS ;
}
 

// Définition de la fonction
// Retourne le chiffre entré en toutes lettres de 0 à 10 ;-)
function enToutesLettres(nombre) {
  // On teste la valeur du paramètre pour voir si il est dans la plage fixée
  if (nombre > 10 || nombre < 0) { return "Traite seulement les chiffres de 0 à 10 !" ; }
  if (nombre==0) { return "zéro" ; }
  if (nombre==1) { return "un" ; }
  if (nombre==2) { return "deux" ; }
  if (nombre==3) { return "trois" ; }
  if (nombre==4) { return "quatre" ; }
  if (nombre==5) { return "cinq" ; }
  if (nombre==6) { return "six" ; }
  if (nombre==7) { return "sept" ; }
  if (nombre==8) { return "huit" ; }
  if (nombre==9) { return "neuf" ; }
  if (nombre==10) { return "dix" ; }
  // On ne devrait jamais arriver ici
  return   "Il y a un problème !" ;
}
 
// Utilisation de la fonction
console.log(enToutesLettres(3)) ; // Affichera trois
console.log(enToutesLettres(6)) ; // Affichera six
console.log(enToutesLettres(9)) ; // Affichera neuf

// Définition de la fonction
// Retourne le chiffre entré en toutes lettres de 0 à 10 ;-)
function enToutesLettres(nombre) {
  // On teste la valeur du paramètre pour voir si il est dans la plage fixée
  if (nombre > 10 || nombre < 0) { return "Traite seulement les chiffres de 0 à 10 !" ; }
  if (nombre==0) { return "zéro" ; }
  if (nombre==1) { return "un" ; }
  if (nombre==2) { return "deux" ; }
  if (nombre==3) { return "trois" ; }
  if (nombre==4) { return "quatre" ; }
  if (nombre==5) { return "cinq" ; }
  if (nombre==6) { return "six" ; }
  if (nombre==7) { return "sept" ; }
  if (nombre==8) { return "huit" ; }
  if (nombre==9) { return "neuf" ; }
  if (nombre==10) { return "dix" ; }
  // On ne devrait jamais arriver ici
  return   "Il y a un problème !" ;
}
 
// Utilisation de la fonction
console.log(enToutesLettres(3)) ; // Affichera trois
console.log(enToutesLettres(6)) ; // Affichera six
console.log(enToutesLettres(9)) ; // Affichera neuf

<?php
// Définition de la fonction
// Crée retourne une histoire avec les noms passés en paramètres
function histoire($nomPrince, $superPouvoir, $nomPrincesse, $nomSorciere) {
  $prepa='Il était une fois il y a bien longtemps, une princesse nommée '.$nomPrincesse.' fut enlevée par '.
  'la sorcière '.$nomSociere.'. Mais heureusement, arriva le prince '.$nomPrince.' qui grâce à '.
  'son super pouvoir, '.$superPouvoir.', terrassa la princesse '.$nomPrincesse.' et épousa la sorcière '.
  $nomSorciere.'. Oups !!!' ;
 
  return $prepa ;
}
 
echo "Voici ce qui arrive quand on veut aller trop vite et qu'on ne fait pas attention:<br/>".
histoire('Kevin', 'la sieste', 'Cent-Vingt Drillons', 'Bien-Aimée')."<br/>";

<?php
// Définition de la fonction
// Crée retourne une histoire avec les noms passés en paramètres
function histoire($nomPrince, $superPouvoir, $nomPrincesse, $nomSorciere) {
  $prepa='Il était une fois il y a bien longtemps, une princesse nommée '.$nomPrincesse.' fut enlevée par '.
  'la sorcière '.$nomSociere.'. Mais heureusement, arriva le prince '.$nomPrince.' qui grâce à '.
  'son super pouvoir, '.$superPouvoir.', terrassa la princesse '.$nomPrincesse.' et épousa la sorcière '.
  $nomSorciere.'. Oups !!!' ;
 
  return $prepa ;
}
 
echo "Voici ce qui arrive quand on veut aller trop vite et qu'on ne fait pas attention:<br/>".
histoire('Kevin', 'la sieste', 'Cent-Vingt Drillons', 'Bien-Aimée')."<br/>";

#!/usr/bin/perl
 
use strict;
 
sub concatenation {
        my ($motA, $motB, $lien)=@_;
        my $resu;
 
        $resu = $motA.$lien.$motB;
 
        return $resu;
}
# Appel de la fonction
print "Résultat: ".concatenation("Jean", "Pierre", "-")."\n";
 

#!/usr/bin/perl
 
use strict;
 
sub concatenation {
        my ($motA, $motB, $lien)=@_;
        my $resu;
 
        $resu = $motA.$lien.$motB;
 
        return $resu;
}
# Appel de la fonction
print "Résultat: ".concatenation("Jean", "Pierre", "-")."\n";