- je pensais que pour additionner des variables il fallait utiliser "+=" du coup maintenant je me demande si c'est pas pour simplement rajouter un entier a une variable ? 
+= est un l'opérateur d’affectation additionneur, comme son nom l'indique il additionne une valeur à celle d'une variable et affecte le résultat à cette variable. Autrement dit, écrire a+=b revient à écrire a=a+b.
L'opérateur addition est tout simplement +. Utiliser "+=" c'est un simple raccourci, tout comme i++ est un raccourci pour éviter d'avoir à écrire i=i+1.
Exemple : https://jsfiddle.net/38tLj0ar/
- donc tu me conseille à l'avenir d'utiliser que des variables locales ? pourquoi les globales c'est le mal ^^ ?
C'est mal à cause de ce qui s'apelle la collision de variables, c'est à dire le fait d'écraser des variables utilisées par un autre code sans que cela soit prévu. Exemple : https://jsfiddle.net/0mj85ynu/
Là c'est un exemple à la con, mais tu imagines bien que quand tu as des bouts de scripts un peu partout ça devient redoutable.
Plus d'infos : https://www.w3.org/wiki/JavaScript_best_practices#Avoid_globals
Concernant l'écouteur de bouton ajout, tu me dis qu'il ne faut pas mettre de () à add et je ne comprend pas bien pourquoi, j'ai suivis les cour gratuit d'openclassroom pour apprendre le javascript et eux a chaque écouteur appellent une fonction avec les (), même quand il n'y a pas de paramètre.
Je ne connais pas le cours d'Openclassroom, mais ce que je peux te dire c'est qu'il y a une différence fondamentale entre mettre des parenthèses ou non.
Quand tu écris add(), c'est un appel de fonction, tu dis à l’interpréteur d'exécuter immédiatement la fonction add.
Quand tu écris add sans parenthèses, tu es simplement en train de désigner l'objet de type Function qui contient le code de ta fonction add.
Pour plus d'infos : https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions
Pour t'en convaincre, dis toi que
function add(a, b) {
return a+b
}
est presque équivalent à
const add = function (a, b) {
return a+b
}
Et donc tu peux faire des choses comme :
function apply(a, une_fonction_unaire){
return une_fonction_unaire(a) // on applique la fonction une_fonction_unaire avec a en paramètre
}
const plus10 = function(x){ return x+10}
function moins10(x){return x-10)
apply(100, plus10) // retourne 110
apply(100, moins10) // retourne 90
C'est d'ailleurs exactement ce qui se passe avec addEventListener. Tu lui donne un objet Function (appelé dans ce cas un Listener), lui l'enregistre dans sa liste de Listeners (d'où le nom, addEventListener), et il appellera cette fonction à chaque fois que l'évènement voulu se déclenchera.
Note1 : je dis presque parce qu'il y a une différence fondamentale entre les deux déclarations. Dans le premier cas la fonction est disponible pour l'ensemble du script dès son initialisation, mais ce n'est pas vrai pour le second cas. Autrement dit,
add(1,2) // fonctionne pourtant add est déclarée après.
function add(a,b){ return a+b }
add2(1,2) // error: TypeError: add2 is not a function --> add2 n'existe encore pas à ce stade
const add2 = function(a, b) {return a+b}
Note 2:
Quand tu écris
ajout.addEventListener('input', function (e){
ajout = e.target.value;
});
C'est comme si tu écrivais :
// Ceci est une déclaration de fonction, pas un appel
const mafonction = function(e){ajout = e.target.value}
// On enregistre mafonction comme Listener de ajout.
ajout.addEventListener('input', mafonction)
