Bazdebaz Scripting

La syntaxe depend du language utilisé et on retrouve souvent les memes choses.

Par exemple :

• les parentheses ( ) qui contiennent souvent des parametres de fonctions.
• les accolades { } qui contienent les instructions de la fonction.
• le point virgule ; qui finit les lignes d'instructions.

Une variable est un emplacement de la memoire qui contient une information.

on peut nommer une variable et lui assigner une valeur (information).

par exemple :

toto = 1

Dans ce cas, toto est un chiffre, ça aurait pu etre un texte qu'on appelle chaine de caracteres, entourée par des “guillemets”.

certains langages aiment qu'on leur dise de quel type est une variable comme du texte ou un entier naturel ou un vehicule…

donc on dit un truc du genre :

int toto = 1

qui veut dire que toto doit etre une entier donc si tu lui dis :

toto = "blabla"

tu lui donnes un texte alors il couine… tu lui donnes 24 et il est content. :)

Tout ça par ce qu'en fait, au debut du script, tu dois declarer ta variable. Donc si tu lui dis direct :

tutu = "abcd"

l va te dire que tutu n'existe pas (si le language impose le typage). Alors il faudrait lui dire d'abord au debut du script :

str tutu = "abcd"

comme ça il sait que tutu est une chaine de caracteres (string).

il existe plein de types de données par défaut comme int, float, str, array etc… et on peut meme en créer selon le language utilisé.

en gros, c'est que si une condition est vraie, alors il se passera quelque chose sinon il se passera autre chose. Du genre :

if (toto == 24) { faispeter() } else { faisAutreChose() }

Ce qui veut dire que si toto est égal à 24 (oui, il y a 2 signes egal et il peut y en avoir 3) alors la fonction faispeter est appelee sinon la fonction faisautrechose est appelée.

Les fonctions permettent d'ecrire une seule fois un bout de code qui pourra reservir plusieurs fois.

Par exemple, si tu as 5 clous à planter, au lieu d'ecrire :

prendsLeClou
prendsLeMarteau
viseLePoint
tapeSurLeClouAvecLeMarteau
prendsLeClou
prendsLeMarteau...etc..

tu ecris :

function planterUnClou() {
  prendsLeClou()
  prendsLeMarteau()
  viseLePoint()
  tapeSurLeClouAvecLeMarteau()
}
planterUnClou()
planterUnClou()
planterUnClou()
planterUnClou()
planterUnClou()

Apres la declaration ou appel de fonction, il y a des parentheses. Elles servent à donner des infos externes à la fonction. Par exemple :

<code>function planterUnClou(positionX,positionY) {
  prendsLeClou()
  prendsLeMarteau()
  viseLePoint(positionX, positionY)
  tapeSurLeClouAvecLeMarteau()
}

La fonction va utiliser les arguments qu'on lui a passés

Une fonction peut renvoyer une information. Par exemple :

function addition(a, b) {
  return a+b
}

donc tu peux lui dire :

toto = addition(3+4)

Alors toto aura la valeur 7.

Il y en a de plusieurs types mais les plus classiques sont for et while.

Attention aux boucles qui peuvent bloquer le programme…

On lui donne une valeur de départ, la valeur d'arret, puis un incrément.

En increments, selon le language, si on veut augmenter de 1, on utilise soit :

• x = x + 1
• x++
• x+ = 1

Ces 3 lignes disent la meme chose.

Exemple :

for (x=0; x<5; x++) {
  planterUnClou(x,addition(3+x))
}

Dans ce cas, le script va planter 5 clous :

• un avec les coordonnées x 0 et y 3
• un avec les coordonnées x 1 et y 4
• un avec les coordonnées x 2 et y 5
• un avec les coordonnées x 3 et y 6
• un avec les coordonnées x 4 et y 7

On lui donne une condition et elle tourne tant que c'est pas arrivé.

Exemple :

int y = 0
while (y<10) {
  planterUnClou(4,y)
  y++
}

Ceci va planter un clou aux coordonnées x = 4 et y = 0 puis va en mettre un tout droit vers le haut tous les 1 et quand on arrive à 10, ça s'arrete.

La grande analogie classique pour parler des objets, c'est les vehicules mais vu qu'on est dans le pestacle, nous allons parler d'appareil.

• Les objets sont représentés par une classe.
• Une classe peut contenir des arguments (variables internes)
• Une classe peut contenir des methodes (fonctions internes)

Je peux définir plusieurs classes comme : appareil; visseuse, synthé, consoleSon…

Par exemple, on va créer une classe “appareil” :

class appareil(marque, modele) {
  str marque;
  str modele;
  function allumer() {
    if (power=="ok") {
      return true;
    }
    return false;
  }
}

puis une classe “consoleSon” :

class consoleSon(nbreEntrees, nbreSorties) {
  str nbreEntrees;
  str nbreSorties;
  int niveauSonore;
  function mettrePlusFort() {
    this.niveauSonore++
  }
}

Une classe définit une entité qui pourra eventuellement etre instanciée.

Si on a une console son yamaha cl3, on peut générer cette console.

apres avoir créée la classe, on peut s'en servir comme :

consoleAudiberty = new consoleSon(16, 8)

Donc ensuite, on pourra utiliser :

consoleAudiberti.mettrePlusFort()

Pour les classes, arguments et methodes, on peut definir des autorisations. Les classiques sont public, private…

class consoleSon(nbreEntrees, nbreSorties) {
  private str nbreEntrees;
  private str nbreSorties;
  public function mettrePlusFort() {
    this.niveauSonore++
  }
  public function changeEntrees(quantite) {
    this.nbreEntrees = quantite
  }
  public function changeSorties(quantite) {
    this.nbreSorties = quantite
  }
}

On ne pourra plus appeler :

consoleAudiberti.nbreEntrees = 42

alors ce sera :

consoleAudiberti.changeEntrees(42)

Dans notre cas, on voit bien qu'une console son est un appareil, donc on peut la créer à partir d'une autre classe :

class consoleSon(nbreEntrees, nbreSorties) extends appareil {
  private str nbreEntrees;
  private str nbreSorties;
  public function mettrePlusFort() {
    this.niveauSonore++
  }
  public function changeEntrees(quantite) {
    this.nbreEntrees = quantite
  }
  public function changeSorties(quantite) {
    this.nbreSorties = quantite
  }
}

Sauf que cette fois, on pourra l'allumer et changer la marque ou modele…