Является ли передача аргумента лучшим решением для решений if / else

#javascript #if-statement #parameters #arguments

#javascript #if-statement #параметры #аргументы

Вопрос:

Использование аргументов / параметров для определения того, какой путь используется с помощью инструкции if / else, работает для меня, но я чувствую, что могло бы быть лучшее решение. Есть ли что-то, что больше похоже на идентификатор, который я мог бы передать вместо аргумента / параметра? Может быть, я слишком много думаю об этом?

У меня есть две отдельные функции, dog () и cat (), каждая из которых вызывает третью функцию: mouse (). В настоящее время я отправляю уникальный аргумент через общий параметр вместе с dog() и cat() для направления каждой функции по разным путям в операторе if / else внутри функции mouse().

Вот мой пример, который работает так, как ожидалось:

 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')
  }
}

Есть вторичная проблема, которая заключается в том, что у меня есть много функций, вызывающих mouse(), и я не хочу определять переменную solo для каждой из них. Я бы предпочел, чтобы функции, которые не solo определены, просто использовали else часть условного выражения внутри function mouse() . Однако я беспокоюсь, что это не очень хорошая практика, поскольку она выдает undefined ошибку.

Например, это выдает undefined ошибку.

 mouse();

function mouse(solo, x) {

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

Фактический код:

 <!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>

1. Когда вы пытаетесь войти в систему x , которая не определена, она будет регистрироваться undefined . Я не вижу здесь никаких TypeError or SyntaxError . Не могли бы вы, пожалуйста, уточнить? Кроме того, это определенно относится к else части.

2. Вам не нужно каждый раз определять переменную, вы можете просто вызвать mouse(1, 25); Звучит так, как будто вы думаете, что вам нужно передать переменную name solo , чтобы иметь возможность прочитать ее внутри mouse , но это не так. И ссылка на неопределенные переменные не имеет большого значения, например, вы можете сделать if (x) console.log(x) , чтобы регистрировать их только в том случае, если они определены.

3. Можете ли вы показать часть своего фактического кода? Приведенный вами пример кода не очень подходит для того, чтобы показать, как его улучшить, в основном потому, что функции должны устранять дублирующийся код, но ваша функция mouse сама содержит дублирующийся код.

4. Спасибо, @Praveen, это правда, я не получаю никаких других ошибок, просто «не определено». Допустимо ли иметь что-то неопределенное? Он переходит к другой части функции, которая работает должным образом.

5. @forestkelley Это определенно нормально. Это ведение журнала, потому что вы ведете журнал. Вы можете избежать регистрации undefined, как это сделал ChrisG в своих комментариях выше. :)

Ответ №1:

Вместо этого можно поместить некоторый абстрактный идентификатор в solo переменную, поместить значение, которое будет использоваться непосредственно в «алгоритме» (здесь просто выведите в консоли).

 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) 
}

В дальнейшем вы можете разделить функцию мыши на отдельные функции дерева — одну, которая имеет общие «вычисления», и две, которые имеют индивидуальные вычисления для собаки и кошки

1. Это. Это самое простое и наилучшее решение, если только нет дополнительных ограничений, о которых OP нам не сообщил. Но даже их, вероятно, следует решать путем отправки более сложных значений, а не путем выполнения ветвления в mouse .

2. @Bergi вы хотите сказать, что отправка более сложных значений является желательной стратегией? Ветвление — это плохо? (Я пока не совсем понимаю, что означают эти термины, но мне интересно)

3. @forestkelley Сложно давать абсолютные и общие рекомендации в комментариях 🙂 Но фактический код, который вы опубликовали, показывает, что моя догадка была правильной. Эти if/else лестницы ужасны! Вместо этого используйте соответствующую структуру данных, например массив объектов, для вашего optionsA , а затем найдите нужный объект (индекс) для работы с помощью цикла.

4. @Bergi похоже, мне нужно немного научиться. Некоторые из используемых вами терминов (лестницы и структуры данных) Я не знаком с. И я не совсем уверен, как вы представляете себе структурирование этого массива объектов, но я проведу некоторый поиск. Если у вас есть ссылка, которая демонстрирует эти подходы, я бы хотел посмотреть. Спасибо за совет. Я с нетерпением жду более чистого подхода!

5. @forestkelley «Лестница» — это просто жаргонный термин для длинного ряда if … else if … else if … . Структуры данных (и алгоритмы на них) являются наиболее важным инструментом для программирования, вы определенно должны узнать о них. Я имею в виду использование массива [{startMin: 0, startMax: 8000, …}, {startMin:0, startMax: 30000, …}, …] вместо перечисленных «групп» свойств.

Ответ №2:

вы можете установить значение по умолчанию.

например

 mouse();

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

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

затем вы можете проверить это, и переменные будут определены автоматически, также, если они не заданы в качестве параметра

кроме того, в более старом браузере вы можете сделать это также таким образом:

 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')
  }
}

1. затем нажмите F12, ctrl c и ctrl v и попробуйте это

2. Ну, я не такой тупой, иначе я не стал бы заниматься проектом Chromium. 😉

3. что ж, я согласен с вашей правкой в том, что я также не знаю, работает ли это во всех браузерах. Но это происходит, по крайней мере, в текущих Chrome и Firefox.

4. Да. Это верно. Я знаю об этом. В любом случае, спасибо, приятель. 😇

Ответ №3:

Я не уверен, зачем вам нужно if else, когда вы делаете одно и то же в каждой ветви этого дерева решений. Если вы параметризуете выходные данные, вы можете сделать что-то подобное с помощью частичного приложения:

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

Ответ №4:

Вы можете упростить задачу, используя каррирование, как в следующем коде:

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

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

Функция animal принимает ‘name’ животного и передает его анонимной функции, которая принимает параметры solo и x, которые также передаются в операцию терминала — в данном случае для входа в консоль. Поскольку в вашем примере в каждом случае вызывается мышь, которая выполняет только операцию протоколирования, здесь она используется как операция терминала.

Обратите внимание на отсутствие необходимости в конструкции if / else в этом случае.

1. Я заинтригован этим ответом, но пока недостаточно разбираюсь в currying, чтобы знать, удовлетворит ли это мои потребности. Мне потребуется некоторое время, чтобы обдумать это и отчитаться.

2. когда у вас появятся вопросы, задавайте. Я буду рад объяснить.