使用参数/参数来确定通过 if/else 语句采用的路径对我有用，但我觉得可能有更好的解决方案。有什么东西更像是我可以传递的 ID 而不是参数/参数吗？也许我想多了？
我有两个独立的函数，dog() 和 cat()，每个函数都调用第三个函数:mouse()。我目前正在通过共享参数连同 dog() 和 cat() 发送一个独特的参数，以通过函数 mouse() 内的 if/else 语句中的不同路径引导每个函数。
这是我的示例，它按预期工作:
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 的函数简单地利用 function mouse() 中条件的 else 部分。但是，我担心这不是好的做法，因为它会抛出 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>最佳答案
可以改为将一些抽象 ID 放入 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)
}作为备选方案，您可以将鼠标功能划分为树形独立功能 - 一个具有共同的“计算”，两个具有针对狗和猫的单独计算
关于javascript - 传递参数是 if/else 决策的最佳解决方案，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/55111028/