Fonction dans une boucle qui ne fonctionne pas

Version imprimable

Bonjour,

voila ce tres simple script, qui me fait tourne en rond, un coup ca fonctionne (ou tout au moins ca fonctionnait), et puis ca bug.... quelqu un saurait m'eclairer ??? merci.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
<!DOCTYPE html>
<html>
  <head>
      <meta charset ="utf-8"/>
      <title>jeu j.s</title>
 
      <script type="text/javascript">
        function nb_aleatoire(min, max)
        {
             var nb = min + (max-min+1)*Math.random();
             return Math.floor(nb);
        }
 
        function PoM_manche(min, max, de)
        {
           var nbr = 0;
 
           var joueur = prompt('trouvez un nombre entre '+min+' et '+max);
            
            do//jusque ici tout va bien. c'est dans cette boucle que ca plante...
            {
              nbr++;
              if(isNaN(joueur) || (joueur < min) || (joueur > max))
                joueur = prompt('il faut entrer un chiffre entier compris entre '+min+' et '+max);
              else if(joueur > de)
                joueur = prompt('votre nombre est trop grand');
              else (joueur < de)
                joueur = prompt('votre nombre est trop petit');
              
            } 
            while(joueur != de)
 
            return nbr;
        }
 
      </script>
 
  </head>
 
  <body>
    <script type="text/javascript">
 
      var min;
      var max;
     
      min = prompt('choisissez un petit nombre');
      do
      {
      max = prompt('choisissez un nombre plus grand');
      }
      while(parseInt(min) > parseInt(max));//la ca fonctionne sans parseInt(), puis d'un coup ca plante ??? puis des que je remet parseInt() tout va bien ???
 
          //la si je ne mets pas 'parseInt()' ca ne fonctionne pas ??   
      var de = nb_aleatoire(parseInt(min), parseInt(max));
 
      //histoire de ne pas tourner en rond
      alert("le chiffre a trouver est " +de);
 
      var res = PoM_manche(parseInt(min), parseInt(max), parseInt(de));
 
      alert('vous avez gagne en : '+res+' coups');
 
          
    </script>
  </body>
</html>

:salut:

Plusieurs corrections, la principale parseInt(unNombre, 10), voir : https://developer.mozilla.org/fr/doc...obaux/parseInt

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
    function nb_aleatoire(min = 0, max = 10) {
        // retourne X tel que : min <= X <= max
        return Math.floor(Math.random() * (max - min + 1) + min);
    }
 
    function PoM_manche(min, max, de) {
        let
            nbr = 0,
            joueur = prompt('trouvez un nombre entre ' + min + ' et ' + max);
 
        do {
            nbr++;
 
            if (isNaN(joueur) || (joueur < min) || (joueur > max)) {
                joueur = prompt('il faut entrer un chiffre entier compris entre ' + min + ' et ' + max);
            } else if (joueur > de) {
                joueur = prompt('votre nombre est trop grand');
            } else if (joueur < de) {
                joueur = prompt('votre nombre est trop petit');
            }
        } while (joueur != de);
 
        return nbr;
    }
 
    let
        min = 0,
        max = 10;
 
    min = parseInt(prompt('choisissez un petit nombre'), 10);
 
    do {
        max = parseInt(prompt('choisissez un nombre plus grand'), 10);
    } while (min > max);
 
    let de = nb_aleatoire(min, max);
 
    //histoire de ne pas tourner en rond
    alert("le chiffre a trouver est " + de);
 
    let res = PoM_manche(min, max, de);
 
    alert('vous avez gagne en : ' + res + ' coups');

Bonjour Daniel,

Merci pour la correction (et le lien), cela fonctionne a merveille. J ai aussi pris note de l'utilisation de 'let' plutot que de 'var', et pour mieux comprendre j'ai fait quelques recherches, ce qui m'a surpris c'est que https://www.w3schools.com/js/js_let.asp explique qu'une fois que 'let' a ete initialise, sa valeur ne peut plus etre redeclare dans le meme scope (contrairement a 'var').
Code:

1 2 3 4 5 6 7 8 9 10 //Redeclaring a JavaScript variable with var is allowed anywhere in a program: var x = 2; // Now x is 2 var x = 3; // Now x is 3
Dans votre correction 'let max = 10' (ligne 28) puis redeclarer dans la boucle while correspond a leurs explications
Code:

1 2 3 4 5 6 7 8 9 10 11 12 //Redeclaring a variable with let, in another scope, or in another block, is allowed: let x = 2; // Allowed { let x = 3; // Allowed } { let x = 4; // Allowed }
par contre dans la function PoM_manche() (ligne 6) 'let nbr' est redeclare continuellement au fil son incrementation, ce qui s'oppose a leurs explications (mais fonctionne parfaitement dans votre correction)
Code:

1 2 3 4 5 6 7 8 9 10 //Redeclaring a let variable with let, in the same scope, or in the same block, is not allowed: let x = 2; // Allowed let x = 3; // Not allowed { let x = 4; // Allowed let x = 5; // Not allowed }
Du coup j'ai remplacer tour a tour les 'let' par des 'var', dans les deux cas tout fonctionne. Qu'en penssez vous ?

ps: Je ne veux surtout pas abuser plus de votre temps (deja un grand Merci pour cette correction), donc si vous avez encore un petit moment, votre avis de pro pourra certainement (encore une fois) m'aider a mieux comprendre.

17/06/2019, 10h54
danielhagnoul

Citation:

Envoyé par djedjethai

Bonjour Daniel,

Merci pour la correction (et le lien), cela fonctionne a merveille. J ai aussi pris note de l'utilisation de 'let' plutot que de 'var', et pour mieux comprendre j'ai fait quelques recherches, ce qui m'a surpris c'est que https://www.w3schools.com/js/js_let.asp explique qu'une fois que 'let' a ete initialise, sa valeur ne peut plus etre redeclare dans le meme scope (contrairement a 'var'). [...]

Cette référence - a oublié d'urgence, est connue pour son à peu près, elle confond sans doute let avec const !

En dehors de DVP (vous y êtes), il y a une seule référence valable pour le langage JS, c'est MDN. Voir : https://www.developpez.net/forums/bl...formation-mdn/
17/06/2019, 11h26
Watilin
Citation:

Envoyé par djedjethai

par contre dans la function PoM_manche() (ligne 6) 'let nbr' est redeclare continuellement au fil son incrementation, ce qui s'oppose a leurs explications (mais fonctionne parfaitement dans votre correction)

Attention à ne pas confondre déclaration et affectation :
Code:

1 2 let nbr = 0; // déclaration nbr++; // affectation, forme courte de nbr = nbr + 1;
On peut (ré)affecter une variable autant de fois qu’on veut, du moment qu’elle a été déclarée.

Bien sûr, on ne peut pas réaffecter une variable déclarée avec const, mais dans ce cas-là on n’appelle plus ça une variable, mais plutôt une constante :)

Il y a aussi cette notion de portée (scope) à ne pas oublier : nbr appartient à la portée de la fonction PoM_manche(). Pour être plus précis : nbr appartient à la portée d’un appel à la fonction PoM_manche(). À chaque appel, une nouvelle portée est créée, et donc les variables sont différentes.

Remarque qu’une portée de fonction (function scope) est aussi une portée de bloc (block scope). Les deux codes suivants sont équivalents :
Code:

1 2 3 { let x; }
Code:

1 2 3 (function () { let x; })();
L’inverse n’est pas vrai : une portée de bloc n’est pas forcément une portée de fonction. Par exemple :
Code:

1 2 3 4 5 6 7 8 9 function f() { let a; // dans la portée de la fonction if (true) { let b; // dans la portée du bloc if } // ici, b n’existe pas }
Enfin, n’oublie pas que si tu oublies de déclarer une variable, elle devient globale accidentellement. Pour rendre cette erreur plus facile à déceler, utilise le mode strict.
17/06/2019, 12h00
djedjethai

Merci pour ces explications/precisions et pour les bonnes adresses, super ! Je pense que tout est dit, je clic resolu.