Category: bases_programmation

  • đŸ€– Bases de la programmation : Les Fonctions

    Concept

    Le concept de fonction viens de la notation mathĂ©matique “f(x)” : pour reprĂ©senter le resultat d’une modification d’une valeur abstraite “x” par une sĂ©riĂ© d’opĂ©ration (mutiliplication , addition ect … ) . Mais on peut aussi penser aux fonctions comme Ă  des “verbes” dans un language. Certain verbes n’ont pas d’objets comme “dormir” et certain supposent un objet comme “manger qq”.

    On peut aussi voir les fonction comme des “tuyaux” dans lesquelles passent les valeurs du programme afin d’ĂȘtre transformĂ©es. Elles ont comme input les “arguments” et comme output une valeur de retour “return”.

    L’utilisation des fonctions n’est pas obligatoires pour qu’un programme fonctionne mais elles amĂ©liorent grandement son organisation et sa lisibilitĂ©.

    DĂ©claration

    La dĂ©finition d’un verbe dans un dictionnaire est trĂšs proche d’un code de dĂ©claration de fonction.

    DĂ©clarer une fonction signifie dĂ©crire son comportement. C’est son “plan d’action” sous forme de code . Le code contenu entre les balises {} sera exĂ©cutĂ© au moment de son “appel”. 

    function sayhello() {
   MessageLog.trace("hello")
}

    Appel

    Pour appeller une fonction et executer son code il suffit d’Ă©crire son nom suivi de parenthĂšses ()

    
function sayhello() {
   MessageLog.trace("hello")
}

sayhello()
sayhello()
sayhello()

// affiche 
// hello
// hello 
// hello

    Fonctions avec argument

    Les fonctions avec argument ont pour but de “faire quelque chose” avec une variable. Au moment de la dĂ©claration on ne connais pas la valeur de la variable qui va ĂȘtre transmise alors on utilise une abstraction. Quelque chose qui peut varier mais dont le contenu est globalement prĂ©visible comme “aliment” ou “fruit” si on veut parler d’une fonction “manger” par exemple.

    Comme dans une dĂ©finition de dictionnaire oĂč l’on prĂ©cise qu’un verbe attends une certains catĂ©gorie de mots aprĂšs lui : parler_Ă (quelqu’un)

    Plus simplement : lorsque l’on dĂ©fini un argument on dĂ©fini les “input” de la fonction un peu comme les inports d’un groupe dans la nodeview

    
function say(_word) {
   MessageLog.trace(_word)
}
say("bonjour")
// affiche : 
// bonjour

function manger(_aliment) {
   MessageLog.trace(" je mange "+_aliment)
}

manger("une pomme")
// affiche : 
// je mange une pomme 


function stand_up_introduction(_word,_city) {
   MessageLog.trace("HEY ")
   MessageLog.trace(_word)
   MessageLog.trace(_city)
   MessageLog.trace("!")
}

stand_up_introduction("bonjour","toulouse")

// affiche :
// HEY 
// bonjour
// toulouse
// !

    Fonctions avec valeur de retour

    Les fonctions avec valeur de retour vont pouvoir donner une valeur lorsqu’elle sont appelĂ©es : Dans cet example la fonction se comporte comme une valeur qu’on transmet Ă  la variable “test”

    function myfunc() {
   return "ma_valeur_de_retour"
}

var test = myfunc()
MessageLog.trace(test)
// affiche ma_valeur_de_retour

    dans la dĂ©claration on dĂ©cide de la valeur que transmettra la fonction avec le mots clef “return” . C’est l’output de la fonction. Comme dans un groupe dans la nodeview c’est son port out, Ă  la diffĂ©rence qu’une fonction ne peut avoir qu’un seul output.

    On peut biensur “retourner” une variable dĂ©clarĂ©e dans la fonction 

    function myfunc() {
   var msg= "bonjour"
   return msg
}

var test = myfunc()
MessageLog.trace(test)
// affiche bonjour

    Avec les concepts d’argument et de return on peut maintenant Ă©crire des petites fonctions mathĂ©matiques simples : 

    function additionner(_A,_B) {
   var somme = _A + _B
   return somme
}

var resultat = additionner(2,2)
MessageLog.trace(resultat)
// affiche 4

    Fonctions Imbriquées

    On peut tout à fait appeler une fonction dans une déclaration de fonction 

    function ajouter_flammes(_mots){
  return "đŸ”„"+_mots+"đŸ”„"
}

function dire_un_bonjour_en_feu_a(_prenom){
  var phrase = " bonjour "+_prenom+" ! "
  phrase = ajouter_flammes(_phrase)
  return phrase
}

var test= dire_un_bonjour_en_feu_a("le chat")
MessageLog.trace(resultat)
// affiche đŸ”„ bonjour le chat ! đŸ”„

    on peut Ă©galement dĂ©clarer et appeler une fonction dans une fonction. Lorsque l’on veut dĂ©composer le code d’une fonction complexe par exemple.

    On peut Ă©crire le code ci dessus comme ce ci : 

    
// fonction principale
function dire_un_bonjour_en_feu_a(_prenom){
  // sous fonction
  function ajouter_flammes(_mots){
    return "đŸ”„"+_mots+"đŸ”„"
  }
  
  var phrase = " bonjour "+_prenom+" ! "
  phrase = ajouter_flammes(_phrase)
  return phrase
}

var test= dire_un_bonjour_en_feu_a("le chat")
MessageLog.trace(resultat)
// affiche đŸ”„ bonjour le chat ! đŸ”„

    Le resultat est le meme. En revanche les autres fonctions n’auront plus acccĂšs Ă  “ajouter flammes” car elle est dĂ©clarĂ© Ă  l’interieur de “dir_un_bonjour_en_feu_a”

    Ce code ne fonctionnera pas :

    // fonction principale
function dire_un_bonjour_en_feu_a(_prenom){
  // sous fonction
  function ajouter_flammes(_mots){
    return "đŸ”„"+_mots+"đŸ”„"
  }
  
  var phrase = " bonjour "+_prenom+" ! "
  phrase = ajouter_flammes(_phrase)
  return phrase
}

// fonction principale
function dire_un_aurevoir_en_feu_a(_prenom){
  var phrase = " aurevoir"+_prenom+" ! "
  // CETTE FONCTION N'EST PAS VISIBLE D'ICI ! 
  phrase = ajouter_flammes(_phrase)
  return phrase
}

var test= dire_un_aurevoir_en_feu_a("le chat")
MessageLog.trace(resultat)
// affiche une erreur

    Pour que “aurevoir” et “bonjour” fonctionnent il faudra replacer “ajouter_flammes” Ă  l’exterieur 

    
function ajouter_flammes(_mots){
  return "đŸ”„"+_mots+"đŸ”„"
}
  

function dire_un_bonjour_en_feu_a(_prenom){
  var phrase = " bonjour "+_prenom+" ! "
  phrase = ajouter_flammes(_phrase)
  return phrase
}

function dire_un_aurevoir_en_feu_a(_prenom){
  var phrase = " aurevoir"+_prenom+" ! "
  phrase = ajouter_flammes(_phrase)
  return phrase
}

var test= dire_un_aurevoir_en_feu_a("le chat")
MessageLog.trace(resultat)
// affiche đŸ”„ aurevoir le chat ! đŸ”„

    On pourrait encore décomposer nos fonction ainsi :

    function ajouter_char_des_deux_cotes(_mots,_char){
  return _char+_mots+_char
}

function ajouter_flammes(_mots){
  return ajouter_char_des_deux_cotes(_mots,"đŸ”„")
}
  

function dire_un_bonjour_en_feu_a(_prenom){
  var phrase = " bonjour "+_prenom+" ! "
  phrase = ajouter_flammes(_phrase)
  return phrase
}

function dire_un_aurevoir_en_feu_a(_prenom){
  var phrase = " aurevoir"+_prenom+" ! "
  phrase = ajouter_flammes(_phrase)
  return phrase
}

var test= dire_un_aurevoir_en_feu_a("le chat")
MessageLog.trace(resultat)
// affiche đŸ”„ aurevoir le chat ! đŸ”„

  • đŸ€– Bases de la programmation : Les Variables : introduction

    Simplement dit : Une variable est un bout d’espace mĂ©moire dans la RAM avec une adresse.

    👉 Si la RAM Ă©tait un terrain constructible dont la surface correspond Ă  sa mĂ©moire disponible, les variables seraient comme les maisons que l’on construit sur ce terrain. Lorsque l’on dĂ©clare une variable on “rĂ©serve” une adresse dans la mĂ©moire avec un nom. Ensuite dans le code ce nom fera rĂ©fĂ©rence au contenu de la variable : sa valeur. C’est un peu comme si , vous habitiez au “153 rue de paris” et que l’on faisait rĂ©fĂ©rence Ă  vous comme “la personne qui au habite au 153 rue de paris“.

    Déclarer une variable : pour déclarer une variable en javascript on utilise le mots clé var suivi du nom de la variable, ici my_variable

    // on déclare l'adresse my_variable 
var my_variable

    Pour assigner une valeur Ă  une variable on utilise l’opĂ©rateur = 

    var my_variable = 10
// la valeur de my_variable est Ă©gale Ă  10

    Appeler une variable : une foi que la variable est dĂ©clarĂ©e et qu’une valeur lui a Ă©tĂ© assignĂ©e, il devient possible de l’appeler. Appeler une variable veut dire lire sa valeur. Pour appeler une variable il suffit d’Ă©crire son nom. Par exemple en utilisant la fonction d’affichage d’Harmony on peut afficher le contenu de my_variable qui est Ă©gal Ă  10 plutot que d’afficher directement la valeur 10 : 

    var my_variable = 10
MessageBox.information(10)
MessageBox.information(my_variable )
// affiche 10 puis 10

    Changer la valeur d’une variable : pour cela il suffit de lui rĂ©assigner une nouvelle valeur avec le signe Ă©gal 

    var A = 10
A = 15

MessageBox.information(A)
// affiche 15

    On peut egalement Ă  l’aide du signe Ă©gal transfĂ©rer une valeur d’une variable Ă  une autre : 

    var A = 10
var B = A

MessageBox.information(A)
MessageBox.information(B)
// affiche 10 puis 10

    Attention Ă  bien respecter l’ordre d’execution !

    var A = 10

MessageBox.information(B)

var B = 20

// ce code renvoi une erreur car B est appelĂ© AVANT d'ĂȘtre dĂ©clarĂ© !

    Les Constantes :

    Il existe une deuxiĂšme type de variable qu’on nomme constante, qui, comme son nom l’indique ne peut pas changer. Si vous ĂȘtes sur qu’une variable va ĂȘtre seulement lue et jamais Ă©crite au cour du code, il est intĂ©ressant de la dĂ©clarer en type constante car celui ci est plus lĂ©gers Ă  traiter pour le processeur (la maison prend moins de place..)

    DĂ©clarer une constante :

    pour dĂ©clarer une constante on utilise le mots clĂ© “const”

    const vitesse_de_la_lumiere = 299 792 458 // mettres par secondes

// si on essaye de changer une constante
vitesse_de_la_lumiere = 10

// cela renvoie normalement une erreur ...

    Les types de Valeurs :

    Il existe plusieurs type de valeurs : int , float , string , array , object

    Le type va dĂ©terminer comment les valeurs interagissent entre elles quand on les manipule avec des opĂ©rateurs ( + , – , * , / , % )

    L’opĂ©rateur + par exemple ne va pas du tout produire la mĂȘme chose si on l’applique Ă  des int ou Ă  des string (chaĂźnes de charactĂšre)

    var A =1
var B = 2
var result = A+B 
MessageBox.information(result )
// affiche 3

A = "1"
B = "2"
result = A+B 
MessageBox.information(result )
// affiche "12"

    Suite >>