Dev Faq
1
votes

Passer un argument est-il la meilleure solution pour les décisions if / else

Utiliser des arguments / paramètres pour déterminer le chemin emprunté par l'instruction if / else fonctionne pour moi, mais j'ai l'impression qu'il y a peut-être une meilleure solution. Y a-t-il quelque chose qui agit plus comme un identifiant que je pourrais transmettre au lieu d'un argument / paramètre? Peut-être que j'y pense trop?

J'ai deux fonctions distinctes, dog () et cat (), qui appellent chacune une troisième fonction: mouse (). J'envoie actuellement un argument unique via un paramètre partagé avec dog () et cat () pour canaliser chaque fonction à travers différents chemins dans une instruction if / else à l'intérieur de la fonction mouse ().

Voici mon exemple qui fonctionne comme prévu: 

<!DOCTYPE html
    PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">

<head>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />

  <script src="js/howler.core.js"></script>
  <script src="js/howler.spatial.min.js"></script>
  <link rel="stylesheet" href="css/styles.css">

</head>

<body>

  <script src="timeprobabilities.js"></script>

  <script>
    ///////////////////////////////////////////////////////////////
    // MASTER START ///////////////////////////////////////////////
    ///////////////////////////////////////////////////////////////

    // initiates fist call to all clocks to each will start and can then be called again

    (function masterStart() {
      setTimeout(function() {
        A();
        TA();
      }, 0);
    }());

    ///////////////////////////////////////////////////////////////
    // LOOPS SHARED OPTIONS ///////////////////////////////////////
    ///////////////////////////////////////////////////////////////

    var options = {
      numberOfSounds: 0,
      maxNumberOfSounds: 10
    };

    function logNumberOfSounds() { // passing options into this before is what broke code
      options.numberOfSounds++;
      //console.log('Number of sounds is: ' + options.numberOfSounds + '########');
    }

    ///////////////////////////////////////////////////////////////
    ///////////////////////////////////////////////////////////////
    ///////////////////////////////////////////////////////////////
    // LOOP A  ////////////////////////////////////////////////////
    ///////////////////////////////////////////////////////////////
    ///////////////////////////////////////////////////////////////
    ///////////////////////////////////////////////////////////////

    function A() {
      var optionsA = {
        // start time minimum and maximum
        startMinA: 0,
        startMaxA: 8000,
        playDurationMinA: 20000,
        playDurationMaxA: 20000,
        maxVolumeA: 1,
        //
        startMinB: 0,
        startMaxB: 30000,
        playDurationMinB: 20000,
        playDurationMaxB: 20000,
        maxVolumeB: 1,
        //
        startMinC: 0,
        startMaxC: 30000,
        playDurationMinC: 20000,
        playDurationMaxC: 20000,
        maxVolumeC: 1,
        //
        startMinD: 0,
        startMaxD: 30000,
        playDurationMinD: 20000,
        playDurationMaxD: 20000,
        maxVolumeD: 1,
        //
        startMinE: 0,
        startMaxE: 30000,
        playDurationMinE: 20000,
        playDurationMaxE: 20000,
        maxVolumeE: 1,
        //
        startMinF: 0,
        startMaxF: 30000,
        playDurationMinF: 20000,
        playDurationMaxF: 20000,
        maxVolumeF: 1,
        //
        startMinG: 0,
        startMaxG: 30000,
        playDurationMinG: 20000,
        playDurationMaxG: 20000,
        maxVolumeG: 1,
        //
        startMinH: 0,
        startMaxH: 30000,
        playDurationMinH: 20000,
        playDurationMaxH: 20000,
        maxVolumeH: 1,
        //
        startMinI: 0,
        startMaxI: 30000,
        playDurationMinI: 20000,
        playDurationMaxI: 20000,
        maxVolumeI: 1,
        //
        startMinJ: 0,
        startMaxJ: 30000,
        playDurationMinJ: 20000,
        playDurationMaxJ: 20000,
        maxVolumeJ: 1,
        //
        startMinK: 0,
        startMaxK: 30000,
        playDurationMinK: 20000,
        playDurationMaxK: 20000
      };

      localClock();

      function localClock() {
        setTimeout(function() {
          soundA(options, optionsA);
        }, 10); // these need to be called with delay so they don't use the other functions' paramaters
      }

      function soundA() {

        soundTA(1, 1); // Use something like this to call soundTA() so that the if/else statement will skip soundTA()

        var soundFileName = 'audio/60.wav';
        var fadeIn = 8000;
        var fadeOut = 8000;

        // calculates startDelay
        (function() {
          if (probabilityValue < probabilityPointA) {
            var startDelay = calculateStartDelay(optionsA.startMinA, optionsA.startMaxA);
          } else if (probabilityValue < probabilityPointB) {
            var startDelay = calculateStartDelay(optionsA.startMinB, optionsA.startMaxB);
          } else if (probabilityValue < probabilityPointC) {
            var startDelay = calculateStartDelay(optionsA.startMinC, optionsA.startMaxC);
          } else if (probabilityValue < probabilityPointD) {
            var startDelay = calculateStartDelay(optionsA.startMinD, optionsA.startMaxD);
          } else if (probabilityValue < probabilityPointE) {
            var startDelay = calculateStartDelay(optionsA.startMinE, optionsA.startMaxE);
          } else if (probabilityValue < probabilityPointF) {
            var startDelay = calculateStartDelay(optionsA.startMinF, optionsA.startMaxF);
          } else if (probabilityValue < probabilityPointG) {
            var startDelay = calculateStartDelay(optionsA.startMinG, optionsA.startMaxG);
          } else if (probabilityValue < probabilityPointH) {
            var startDelay = calculateStartDelay(optionsA.startMinH, optionsA.startMaxH);
          } else if (probabilityValue < probabilityPointI) {
            var startDelay = calculateStartDelay(optionsA.startMinI, optionsA.startMaxI);
          } else if (probabilityValue < probabilityPointJ) {
            var startDelay = calculateStartDelay(optionsA.startMinJ, optionsA.startMaxJ);
          } else {
            var startDelay = calculateStartDelay(optionsA.startMinK, optionsA.startMaxK);
          }
          masterStart(startDelay);
        })();

        function calculateStartDelay(startMin, startMax) {
          return Math.floor(Math.random() * startMax) + startMin;
        }

        function calculatePlayDuration(playDurationMin, playDurationMax) {
          return Math.floor((Math.random() * playDurationMax) + playDurationMin);
        }

        function masterStart(startDelay) {
          setTimeout(function() {
            if (probabilityValue < probabilityPointA) {
              var maxVolume = optionsA.maxVolumeA;
              var playDuration = calculatePlayDuration(optionsA.playDurationMinA, optionsA.playDurationMaxA);
              localClock();
            } else if (probabilityValue < probabilityPointB) {
              var maxVolume = optionsA.maxVolumeB;
              var playDuration = calculatePlayDuration(optionsA.playDurationMinB, optionsA.playDurationMaxB);
              localClock();
            } else if (probabilityValue < probabilityPointC) {
              var maxVolume = optionsA.maxVolumeC;
              var playDuration = calculatePlayDuration(optionsA.playDurationMinC, optionsA.playDurationMaxC);
              localClock();
            } else if (probabilityValue < probabilityPointD) {
              var maxVolume = optionsA.maxVolumeD;
              var playDuration = calculatePlayDuration(optionsA.playDurationMinD, optionsA.playDurationMaxD);
              localClock();
            } else if (probabilityValue < probabilityPointE) {
              var maxVolume = optionsA.maxVolumeE;
              var playDuration = calculatePlayDuration(optionsA.playDurationMinE, optionsA.playDurationMaxE);
              localClock();
            } else if (probabilityValue < probabilityPointF) {
              var maxVolume = optionsA.maxVolumeF;
              var playDuration = calculatePlayDuration(optionsA.playDurationMinF, optionsA.playDurationMaxF);
              localClock();
            } else if (probabilityValue < probabilityPointG) {
              var maxVolume = optionsA.maxVolumeG;
              var playDuration = calculatePlayDuration(optionsA.playDurationMinG, optionsA.playDurationMaxG);
              localClock();
            } else if (probabilityValue < probabilityPointH) {
              var maxVolume = optionsA.maxVolumeH;
              var playDuration = calculatePlayDuration(optionsA.playDurationMinH, optionsA.playDurationMaxH);
              localClock();
            } else if (probabilityValue < probabilityPointI) {
              var maxVolume = optionsA.maxVolumeI;
              var playDuration = calculatePlayDuration(optionsA.playDurationMinI, optionsA.playDurationMaxI);
              localClock();
            } else if (probabilityValue < probabilityPointJ) {
              var maxVolume = optionsA.maxVolumeJ;
              var playDuration = calculatePlayDuration(optionsA.playDurationMinJ, optionsA.playDurationMaxJ);
              localClock();
            } else {
              var maxVolume = optionsA.maxVolumeK;
              var playDuration = calculatePlayDuration(optionsA.playDurationMinK, optionsA.playDurationMaxK);
            }
            loop(options, playDuration, soundFileName, maxVolume, fadeIn, fadeOut);
            console.log('A: ////////////////////////////////// ');
          }, startDelay);
        }
      }
    }

    ///////////////////////////////////////////////////////////////
    ///////////////////////////////////////////////////////////////
    ///////////////////////////////////////////////////////////////
    // SHARED LOOP  ///////////////////////////////////////////////
    ///////////////////////////////////////////////////////////////
    ///////////////////////////////////////////////////////////////
    ///////////////////////////////////////////////////////////////

    function loop(options, playDuration, soundFileName, maxVolume, fadeIn, fadeOut) {

      //console.log('LOOP: soundFileName: ' + soundFileName);
      //console.log('LOOP: playDuration: ' + playDuration);
      //console.log('LOOP: maxVolume: ' + maxVolume);

      if (options.numberOfSounds < options.maxNumberOfSounds) { //Don't create more than the max number of sounds.

        var sound = getSound(soundFileName);
        var id2 = sound.play();


        logNumberOfSounds();

        sound.volume(0);
        sound.fade(0, maxVolume, fadeIn, id2); // FADE IN

        setTimeout(function() {

          sound.fade(maxVolume, 0, fadeOut, id2); // FADE OUT
          options.numberOfSounds--;

          // Attempt to clean up the sound object
          setTimeout(function() {
            sound.stop();
            sound.unload();
          }, fadeOut + 1000);
        }, playDuration);
      }

    }

    // PLAYER FOR MAIN SOUND FUNCTION /////////////////////////////
    function getSound(soundFileName) {
      return new Howl({
        src: [soundFileName],
        autoplay: true,
        loop: true,
        volume: 0,
        fade: 0 // removes the blip
      });
    }

    function TA() {
      var optionsA = {
        reduceVolume: .7,
        ///////////////////////////
        minSamplesA: 0,
        maxSamplesA: 2,
        startMinA: 0,
        startMaxA: 9000,
        minDelayA: 3000,
        maxDelayA: 10000,
        maxVolumeA: 1,
        //
        minSamplesB: 1,
        maxSamplesB: 2,
        startMinB: 0,
        startMaxB: 5000,
        minDelayB: 3000,
        maxDelayB: 10000,
        maxVolumeB: 1,
        //
        minSamplesC: 1,
        maxSamplesC: 4,
        startMinC: 0,
        startMaxC: 45000,
        minDelayC: 3000,
        maxDelayC: 10000,
        maxVolumeC: 1,
        //
        minSamplesD: 1,
        maxSamplesD: 5,
        startMinD: 0,
        startMaxD: 45000,
        minDelayD: 3000,
        maxDelayD: 10000,
        maxVolumeD: 1,
        //
        minSamplesE: 1,
        maxSamplesE: 5,
        startMinE: 0,
        startMaxE: 45000,
        minDelayE: 1000,
        maxDelayE: 10000,
        maxVolumeE: 1,
        //
        minSamplesF: 1,
        maxSamplesF: 3,
        startMinF: 0,
        startMaxF: 45000,
        minDelayF: 1000,
        maxDelayF: 10000,
        maxVolumeF: 1,
        //
        minSamplesG: 1,
        maxSamplesG: 5,
        startMinG: 0,
        startMaxG: 45000,
        minDelayG: 2000,
        maxDelayG: 10000,
        maxVolumeG: 1,
        //
        minSamplesH: 1,
        maxSamplesH: 4,
        startMinH: 0,
        startMaxH: 45000,
        minDelayH: 3000,
        maxDelayH: 10000,
        maxVolumeH: 1,
        //
        minSamplesI: 1,
        maxSamplesI: 3,
        startMinI: 0,
        startMaxI: 45000,
        minDelayI: 2000,
        maxDelayI: 10000,
        maxVolumeI: 1,
        //
        minSamplesJ: 1,
        maxSamplesJ: 2,
        startMinJ: 0,
        startMaxJ: 45000,
        minDelayJ: 3000,
        maxDelayJ: 10000,
        maxVolumeJ: 1,
        //
        minSamplesK: 0,
        maxSamplesK: 1,
        startMinK: 0,
        startMaxK: 45000,
        minDelayK: 3000,
        maxDelayK: 10000,
        maxVolumeK: 1
      };



      localClock();

      function localClock() {
        soundTA(optionsA);
        /*
        // THIS IS WHERE I'M TRYING TO CREATE THE IF/ELSE STATEMENT THAT WILL SKIP soundTA() when TA() is called by another function, A() for example. 
        if (foo == bar) { 
            var maxVolume = 1;
            var numberOfSamples = 1;
            playThunder(numberOfSamples, maxVolume);
        }
        else {
            // do the normal thing and don't skip soundTA()
            soundTA(optionsA);
        }
        */
      }

      function soundTA() {
        console.log('TA(); blunt wood');
        (function() {
          if (probabilityValue < probabilityPointA) {
            var startDelay = calculateStartDelay(optionsA.startMinA, optionsA.startMaxA);
            var minDelay = calculateMinDelay(optionsA.minDelayA, optionsA.maxDelayA);
            var maxVolume = calculateMaxVolume(optionsA.reduceVolume, optionsA.maxVolumeA);
            var numberOfSamples = calculateNumberOfSamples(optionsA.minSamplesA, optionsA.maxSamplesA);
          } else if (probabilityValue < probabilityPointB) {
            var startDelay = calculateStartDelay(optionsA.startMinB, optionsA.startMaxB);
            var minDelay = calculateMinDelay(optionsA.minDelayB, optionsA.maxDelayB);
            var maxVolume = calculateMaxVolume(optionsA.reduceVolume, optionsA.maxVolumeB);
            var numberOfSamples = calculateNumberOfSamples(optionsA.minSamplesB, optionsA.maxSamplesB);
          } else if (probabilityValue < probabilityPointC) {
            var startDelay = calculateStartDelay(optionsA.startMinC, optionsA.startMaxC);
            var minDelay = calculateMinDelay(optionsA.minDelayC, optionsA.maxDelayC);
            var maxVolume = calculateMaxVolume(optionsA.reduceVolume, optionsA.maxVolumeC);
            var numberOfSamples = calculateNumberOfSamples(optionsA.minSamplesC, optionsA.maxSamplesC);
          } else if (probabilityValue < probabilityPointD) {
            var startDelay = calculateStartDelay(optionsA.startMinD, optionsA.startMaxD);
            var minDelay = calculateMinDelay(optionsA.minDelayD, optionsA.maxDelayD);
            var maxVolume = calculateMaxVolume(optionsA.reduceVolume, optionsA.maxVolumeD);
            var numberOfSamples = calculateNumberOfSamples(optionsA.minSamplesD, optionsA.maxSamplesD);
          } else if (probabilityValue < probabilityPointE) {
            var startDelay = calculateStartDelay(optionsA.startMinE, optionsA.startMaxE);
            var minDelay = calculateMinDelay(optionsA.minDelayE, optionsA.maxDelayE);
            var maxVolume = calculateMaxVolume(optionsA.reduceVolume, optionsA.maxVolumeE);
            var numberOfSamples = calculateNumberOfSamples(optionsA.minSamplesE, optionsA.maxSamplesE);
          } else if (probabilityValue < probabilityPointF) {
            var startDelay = calculateStartDelay(optionsA.startMinF, optionsA.startMaxF);
            var minDelay = calculateMinDelay(optionsA.minDelayF, optionsA.maxDelayF);
            var maxVolume = calculateMaxVolume(optionsA.reduceVolume, optionsA.maxVolumeF);
            var numberOfSamples = calculateNumberOfSamples(optionsA.minSamplesF, optionsA.maxSamplesF);
          } else if (probabilityValue < probabilityPointG) {
            var startDelay = calculateStartDelay(optionsA.startMinG, optionsA.startMaxG);
            var minDelay = calculateMinDelay(optionsA.minDelayG, optionsA.maxDelayG);
            var maxVolume = calculateMaxVolume(optionsA.reduceVolume, optionsA.maxVolumeG);
            var numberOfSamples = calculateNumberOfSamples(optionsA.minSamplesG, optionsA.maxSamplesG);
          } else if (probabilityValue < probabilityPointH) {
            var startDelay = calculateStartDelay(optionsA.startMinH, optionsA.startMaxH);
            var minDelay = calculateMinDelay(optionsA.minDelayH, optionsA.maxDelayH);
            var maxVolume = calculateMaxVolume(optionsA.reduceVolume, optionsA.maxVolumeH);
            var numberOfSamples = calculateNumberOfSamples(optionsA.minSamplesH, optionsA.maxSamplesH);
          } else if (probabilityValue < probabilityPointI) {
            var startDelay = calculateStartDelay(optionsA.startMinI, optionsA.startMaxI);
            var minDelay = calculateMinDelay(optionsA.minDelayI, optionsA.maxDelayI);
            var maxVolume = calculateMaxVolume(optionsA.reduceVolume, optionsA.maxVolumeI);
            var numberOfSamples = calculateNumberOfSamples(optionsA.minSamplesI, optionsA.maxSamplesI);
          } else if (probabilityValue < probabilityPointJ) {
            var startDelay = calculateStartDelay(optionsA.startMinJ, optionsA.startMaxJ);
            var minDelay = calculateMinDelay(optionsA.minDelayJ, optionsA.maxDelayJ);
            var maxVolume = calculateMaxVolume(optionsA.reduceVolume, optionsA.maxVolumeJ);
            var numberOfSamples = calculateNumberOfSamples(optionsA.minSamplesJ, optionsA.maxSamplesJ);
          } else {
            var startDelay = calculateStartDelay(optionsA.startMinK, optionsA.startMaxK);
            var minDelay = calculateMinDelay(optionsA.minDelayK, optionsA.maxDelayK);
            var maxVolume = calculateMaxVolume(optionsA.reduceVolume, optionsA.maxVolumeK);
            var numberOfSamples = calculateNumberOfSamples(optionsA.minSamplesK, optionsA.maxSamplesK);
          }
          masterStart(startDelay, minDelay, maxVolume, numberOfSamples);
        })();

        function masterStart(startDelay, minDelay, maxVolume, numberOfSamples) {
          setTimeout(function() {
            var elapsedTime = Date.now() - startTime;
            if (elapsedTime > minDelay) {
              if (probabilityValue < probabilityPointJ) {
                localClock();
              }
              playThunder(numberOfSamples, maxVolume);
              elapsedTime = Date.now() - Date.now(); // define when requiring wait between sample plays
              startTime = Date.now();
            } else { // keep triggering the master clock until the wait time has passed
              setTimeout(function() {
                localClock();
              }, 500);
            }
          }, startDelay);
        }
      }

      function getSoundB(soundFileName, maxVolume, reduceVolume, loop) { // confirmed: these are the 3 arguments from getSound
        var volume = calculateReduceVolume(reduceVolume, maxVolume);
        console.log('maxVolume: ' + maxVolume)
        console.log('volume: ' + volume)
        return new Howl({
          src: [soundFileName],
          autoplay: false,
          loop: loop,
          volume: volume,
          fade: 0
          //pan: 1
        });
      }

      function playThunder(numberOfSoundsToPlay, maxVolume) {
        var potentialThunderSounds = [ // blunt wood hits
          getSoundB('audio/35.wav', maxVolume, 0, false),
          getSoundB('audio/36.wav', maxVolume, 0, false),
          getSoundB('audio/37.wav', maxVolume, 0, false),
          getSoundB('audio/38.wav', maxVolume, 0, false),
          getSoundB('audio/39.wav', maxVolume, 0, false),
          getSoundB('audio/40.wav', maxVolume, 0, false),
          getSoundB('audio/41.wav', maxVolume, 0, false),
          getSoundB('audio/42.wav', maxVolume, 0, false),
          getSoundB('audio/43.wav', maxVolume, 0, false),
          getSoundB('audio/44.wav', maxVolume, 0, false),
          getSoundB('audio/45.wav', maxVolume, 0, false),
          getSoundB('audio/46.wav', maxVolume, 0, false),
          getSoundB('audio/47.wav', maxVolume, 0, false),
          getSoundB('audio/48.wav', maxVolume, 0, false),
          getSoundB('audio/50.wav', maxVolume, 0, false),
          getSoundB('audio/51.wav', maxVolume, 0, false),
          getSoundB('audio/52.wav', maxVolume, 0, false),
          getSoundB('audio/53.wav', maxVolume, 0, false),
          getSoundB('audio/54.wav', maxVolume, 0, false),
          getSoundB('audio/55.wav', maxVolume, 0, false),
          getSoundB('audio/56.wav', maxVolume, 0, false),
          getSoundB('audio/57.wav', maxVolume, 0, false),
          getSoundB('audio/58.wav', maxVolume, 0, false),
          getSoundB('audio/59.wav', maxVolume, 0, false)
        ];
        var soundSequence = [];
        //Randomly pick sounds from the potential sounds and add them to the list
        for (var x = 0; x < numberOfSoundsToPlay; x++) {
          var soundIndex = Math.round(Math.random() * (potentialThunderSounds.length - 1));
          soundSequence.push(potentialThunderSounds[soundIndex]);
        }

        playSoundIfThereIsOne();

        function playSoundIfThereIsOne() {
          var currentSound = soundSequence[0];
          currentSound.play();
          soundSequence.shift();
          currentSound.once('end', playSoundIfThereIsOne);
        }
      }
    } // End Thunder Function
  </script>

  <script src="sharedloop.js"></script>
  <!--contains the shared functions for the main loops-->
  <script src="thunders.js"></script>

  <script src="js/howler.core.js"></script>
  <script src="js/siriwave.js"></script>
  <script src="js/player.js"></script>

</body>

</html>

Il y a un problème secondaire qui est que j'ai beaucoup de fonctions appelant mouse (), et je ne veux pas avoir à définir la variable solo pour chacune d'elles. Je préférerais que les fonctions qui n'ont pas solo définies utilisent simplement la partie else du conditionnel à l'intérieur de function mouse () . Cependant, je crains que ce ne soit pas une bonne pratique car cela génère une erreur non défini .

Par exemple, cela génère une erreur non défini . 

mouse();

function mouse(solo, x) {

  if (solo == 1) {
    console.log(x)
    console.log('cat')
  } else {
    console.log(x)
    console.log('dog')
  }
}

Code actuel: 

cat();

function cat() {
  var solo = 1;
  var x = 50;
  mouse(solo, x);
}

dog();

function dog() {
  var solo = 2;
  var x = 25;
  mouse(solo, x);
}

function mouse(solo, x) {

  if (solo == 1) {
    console.log(x)
    console.log('cat')
  } else {
    console.log(x)
    console.log('dog')
  }
}

9 commentaires

Lorsque vous essayez d'enregistrer x , qui n'est pas défini, il enregistrera undefined . Je ne vois aucune TypeError ou SyntaxError ici. Pouvez-vous clarifier s'il vous plait? En outre, cela va certainement à la partie else .

Vous n'êtes pas obligé de définir une variable à chaque fois, vous pouvez simplement appeler mouse (1, 25); On dirait que vous pensez devoir passer une variable de nom solo afin de pouvoir le lire à l'intérieur de la souris , mais ce n'est pas le cas. Et se référer à des variables non définies n'est pas un gros problème, par exemple, vous pouvez faire if (x) console.log (x) pour ne le consigner que s'il est défini.

Pouvez-vous montrer une partie de votre code actuel? L'exemple de code que vous avez n'est pas adapté pour montrer comment l'améliorer, principalement parce que les fonctions sont censées éliminer le code en double, mais votre fonction de souris contient elle-même du code en double.

Merci, @Praveen, c'est vrai, je n'obtiens aucune autre erreur, juste "indéfini". Est-il acceptable d'avoir quelque chose d'indéfini? Il va à l'autre partie de la fonction qui fonctionne comme prévu.

@forestkelley Tout va bien. C'est la journalisation parce que vous vous connectez. Vous pouvez éviter la journalisation d'indéfini comme ce que ChrisG a donné dans leurs commentaires ci-dessus. :)

OK super. Je vais réfléchir davantage à la solution de @Chris G.

@ChrisG J'ai ajouté mon code actuel.

Votre code actuel est si gravement cassé qu'il n'ajoute aucune valeur ici. Erreurs de syntaxe, fonction déclarée sans paramètres mais paramètres passés qui ne sont pas utilisés, variables utilisées qui ne sont jamais déclarées nulle part ( probabilitéValue , probabilitéPointA ), etc. Un échantillon de travail serait utile.

Ce code peut être optimisé et simplifié de nombreuses manières. Pour commencer, avoir des clés comme minSamplesA , minSamplesB , etc. n'est pas une bonne idée; vous voudrez utiliser un tableau d'objets ici: [{minSamples: 0, ...}, {minSamples: 1, ...}] Si vous faites cela, une fonction comme soundTA sera réduit à seulement cinq ou six lignes.

4 Réponses :

0
votes

vous pouvez définir une valeur par défaut.

par exemple 

function mouse(solo, x) {

  if(solo === undefined) {
    solo = false;
  }
  if(x === undefined) {
    x = false;
  }

  if (solo == 1) {
    console.log(x)
    console.log('cat')
  } else {
    console.log(x)
    console.log('dog')
  }
}

alors vous pouvez le vérifier et les variables sont automatiquement définies, même si elles ne sont pas définies comme paramètre

en plus sur un navigateur plus ancien, vous pouvez le faire aussi ceci manière: 

mouse();

function mouse(solo=false, x=false) {

  if (solo == 1) {
    console.log(x)
    console.log('cat')
  } else {
    console.log(x)
    console.log('dog')
  }
}

4 commentaires

puis appuyez sur F12, ctrl + c et ctrl + v et essayez-le

Eh bien, je ne suis pas si stupide, sinon je ne m'engagerai pas dans le projet Chromium. 😉

Eh bien, je suis d'accord avec votre modification que je ne sais pas non plus si cela fonctionne sur tous les navigateurs. Mais c'est au moins le cas sur Chrome et Firefox actuels.

Ouais. C'est vrai. J'en suis conscient. Bref, merci mon pote. 😇

2
votes

Peut être à la place mettre un identifiant abstrait dans la variable solo , mettre une valeur qui sera utilisée directement dans "algorithme" (ici juste imprimer dans la console). 

cat();

function cat() {
  var x = 50;
  mouse('cat', x);
}

dog();

function dog() {
  var x = 25;
  mouse('dog', x);
}

function mouse(solo, x) {
    console.log(x)
    console.log(solo) 
}

En tant que laternatif, vous pouvez diviser la fonction de la souris en fonctions séparées par un arbre - une qui a des "calculs" communs et deux qui ont des calculs individuels pour chien et chat

5 commentaires

Ce. C'est la solution la plus simple et la meilleure, à moins qu'il y ait des contraintes supplémentaires dont le PO ne nous a pas parlé. Mais même ceux-ci devraient probablement être résolus en envoyant des valeurs plus complexes, et non en faisant des branchements dans mouse .

@Bergi vous dites que l'envoi de valeurs plus complexes est une stratégie souhaitable? La ramification est mauvaise? (Je ne suis pas encore tout à fait clair ce que signifient ces termes, mais cela m'intéresse)

@forestkelley Il est difficile de faire des recommandations absolues et génériques dans les commentaires :-) Mais le code que vous avez posté montre que mon intuition était correcte. Ces échelles if / else sont horribles! À la place, utilisez une structure de données appropriée, comme un tableau d'objets, pour vos optionsA , puis trouvez le bon objet (index) avec lequel travailler en utilisant une boucle.

@Bergi, on dirait que j'ai un peu d'apprentissage à faire. Je ne connais pas certains des termes que vous utilisez (échelles et structures de données). Et je ne sais pas trop comment vous envisagez de structurer ce tableau d’objets, mais je vais faire quelques recherches. Si vous avez un lien qui illustre ces approches, j'aimerais voir. Merci pour le conseil. J’attends avec impatience une approche plus propre!

@forestkelley "Ladder" est juste un terme d'argot pour une longue ligne de if… else if… else if… . Les structures de données (et leurs algorithmes) sont l'outil le plus important pour la programmation, vous devriez certainement renseignez-vous sur eux. Je veux dire utiliser un tableau [{startMin: 0, startMax: 8000,…}, {startMin: 0, startMax: 30000,…},…] au lieu de ces "groupes" de propriétés énumérés.

0
votes

Vous pouvez simplifier les choses en utilisant currying comme dans le code suivant: 

const animal = (pet) => (solo,x) => console.log(pet, x, solo);

animal('dog')(25,1);
animal('cat')(50,2);

La fonction animal prend le nom de l'animal et le transmet à une fonction anonyme qui prend les paramètres solo et x qui sont également passés dans le fonctionnement du terminal - dans ce cas, la connexion à la console. Puisque mouse est appelée dans tous les cas dans votre exemple et n'effectue que l'opération de journalisation, elle est curée ici en tant qu'opération de terminal.

Notez le manque de nécessité pour le if / else construit dans ce cas.

2 commentaires

Je suis intrigué par cette réponse, mais je ne comprends pas encore assez le curry pour savoir s'il répondra à mes besoins. Je prendrai le temps d’y réfléchir et de faire rapport.

au fur et à mesure que vous recevez des questions, posez-les. Je serai heureux de vous expliquer.

0
votes

Je ne sais pas pourquoi vous avez besoin de if else lorsque vous faites la même chose dans chaque branche de cet arbre de décision. Si vous paramétrez la sortie, vous pouvez faire quelque chose comme ceci à l'aide d'une application partielle: 

const mouse = (x, output) => () => {
    console.log(x);
    console.log(output);
}
const dog = mouse(25, "dog")();
const cat = mouse(50, "cat")();

1 commentaires

Dans mon code actuel, chaque branche fait une chose différente.

Articles qui pourrait vous intéresser :

Impossible d'importer le module "@ angular / material"
Interaction profonde avec break and catch
Utilisation de node.js comment renommer tous les fichiers d'un dossier
Google Chrome Uncaught (promis) DOMException lors de la lecture AUDIO