优雅切换许多功能

Question

比方说，我有那个做事功能了一把：

function doStuff() { console.log('doing stuff'); } 
function doThings() { console.log('doing things'); } 
function doIt()  { console.log('doing it'); } 
function doThis() { console.log('doing this'); } 
function doThat() { console.log('doing that'); } 

然后就像许多禁止自己的行为：

function stopStuff() { console.log('stopping stuff'); } 
function stopThings() { console.log('stopping things'); } 
function stopIt()  { console.log('stopping it'); } 
function stopThis() { console.log('stopping this'); } 
function stopThat() { console.log('stopping that'); } 

然后我把所有的“做“在一个对象的功能，所以我可以动态地设置what访问它们：

var what = 'things'; 

var doing = { 
    stuff: function() { doStuff(); }, 
    things: function() { doThings(); }, 
    it:  function() { doIt(); }, 
    this: function() { doThis(); }, 
    that: function() { doThat(); } 
}; 

doing[what](); //console logs 'doing things' 

是否有WA y在遍历所有不匹配的stop函数的同时启用一个do函数？

例如，如果我这样做var what = 'this'; doing[what]();，我希望它不仅doThis();也stopStuff(); stopThings(); stopIt(); stopThat();

我无法想出一个巧妙的方法，不涉及冗长的if语句或case /开关。

Answer 1

如果你所有的DO /停止功能是全球性的 - 本作品

function doStuff() { console.log('doing stuff'); } 
 
function doThings() { console.log('doing things'); } 
 
function doIt()  { console.log('doing it'); } 
 
function doThis() { console.log('doing this'); } 
 
function doThat() { console.log('doing that'); } 
 

 
function stopStuff() { console.log('stopping stuff'); }; 
 
function stopThings() { console.log('stopping things'); }; 
 
function stopIt()  { console.log('stopping it'); }; 
 
function stopThis() { console.log('stopping this'); }; 
 
function stopThat() { console.log('stopping that'); }; 
 

 

 
var run = function(root) { 
 
    var fnNames = ['stuff', 'things', 'it', 'this', 'that']; 
 
    return function(what) { 
 
     fnNames.forEach(function (fn) { 
 
      var fnName = fn[0].toUpperCase() + fn.slice(1); 
 
      root[(what == fn ? 'do' : 'stop') + fnName](); 
 
     }); 
 
    }; 
 
}(window); 
 
// usage 
 
console.log('things'); 
 
run('things'); 
 
console.log('this'); 
 
run('this');

但是，如果他们不是全球性的，这是一个有点混乱，但不是很多

function doStuff() { console.log('doing stuff'); } 
 
function doThings() { console.log('doing things'); } 
 
function doIt()  { console.log('doing it'); } 
 
function doThis() { console.log('doing this'); } 
 
function doThat() { console.log('doing that'); } 
 

 
function stopStuff() { console.log('stopping stuff'); } 
 
function stopThings() { console.log('stopping things'); } 
 
function stopIt()  { console.log('stopping it'); } 
 
function stopThis() { console.log('stopping this'); } 
 
function stopThat() { console.log('stopping that'); } 
 

 
var run = (() => { 
 
    var fns = { 
 
     stuff: { run: doStuff, stop: stopStuff }, 
 
     things: { run: doThings, stop: stopThings }, 
 
     it:  { run: doIt,  stop: stopIt  }, 
 
     "this": { run: doThis, stop: stopThis }, 
 
     that: { run: doThat, stop: stopThat } 
 
    }; 
 
    return what => Object.keys(fns) 
 
     // include the sort only if you need to stop all first before start 
 
     // change a == what to b == what to start selected and then stop the rest 
 
     .sort((a,b) => a == what) 
 
     .forEach(key => fns[key][what == key ? 'run' : 'stop']()); 
 
})(); 
 

 
console.log('things'); 
 
run('things'); 
 
console.log('this'); 
 
run('this');

Answer 2

你可以使用一个简单的for循环，如下面的代码

如果你所有的DO /停止功能是全球 - 这工作

for(var idx in doing) { 
    if(idx == what) { 
     doing[idx](); 
    } 
    else { 
     var fn = idx.charAt(0).toUpperCase() + idx.slice(1); 
     var fname = "stop"+fn; 
     window[fname](); 
    } 
} 

Answer 3

让函数需要一个参数，并通过功能迭代一个数组是除了参数之外，调用它们每一个。例如：

var doing = [ 
    stuff: function(func) { 
    stopping.forEach(element => { 
     if (element !== func) { 
     element() 
     } 
    } 
    doStuff() 
    }, 
    ... 
]; 

var stopping = [ 
    stopStuff: function() { stoppingStuff() }, 
    ... 
]; 

Answer 4

function doStuff() { console.log('doing stuff'); } 
function doThings() { console.log('doing things'); } 
function doIt()  { console.log('doing it'); } 
function doThis() { console.log('doing this'); } 
function doThat() { console.log('doing that'); } 

function stopStuff() { console.log('stopping stuff'); } 
function stopThings() { console.log('stopping things'); } 
function stopIt()  { console.log('stopping it'); } 
function stopThis() { console.log('stopping this'); } 
function stopThat() { console.log('stopping that'); } 

var what = 'things'; 

var doing = { 
    stuff: doStuff, 
    things: doThings, 
    it:  doIt, 
    this: doThis, 
    that: doThat 
}; 

var stopping = { 
    stuff: stopStuff, 
    things: stopThings, 
    it:  stopIt, 
    this: stopThis, 
    that: stopThat 
}; 

var a = Object.keys(stopping); 
a.splice(a.indexOf(what), 1); 
Object.keys(stopping).map(function(key) { 
    return stopping[key](); 
}); 
doing[what](); 

Answer 5

双向，您可以在这取决于运行的额外功能的成本做。

1. 在开始新的do函数之前调用所有stop函数。

2. 或过滤特定的停止功能。

     function doStuff() { 
         console.log('doing stuff'); 
        } 
   
        function doThings() { 
         console.log('doing things'); 
        } 
   
        function doIt() { 
         console.log('doing it'); 
        } 
   
        function doThis() { 
         console.log('doing this'); 
        } 
   
        function doThat() { 
         console.log('doing that'); 
        } 
   
        function stopStuff() { 
         console.log('stopping stuff'); 
        } 
   
        function stopThings() { 
         console.log('stopping things'); 
        } 
   
        function stopIt() { 
         console.log('stopping it'); 
        } 
   
        function stopThis() { 
         console.log('stopping this'); 
        } 
   
        function stopThat() { 
         console.log('stopping that'); 
        } 
   
        var what = 'things'; 
   
        var doing = { 
         stuff: function() { 
          doStuff(); 
         }, 
         things: function() { 
          doThings(); 
         }, 
         it: function() { 
          doIt(); 
         }, 
         this: function() { 
          doThis(); 
         }, 
         that: function() { 
          doThat(); 
         } 
        }; 
   
        var stopping = { 
         stuff: function() { 
          stopStuff(); 
         }, 
         things: function() { 
          stopThings(); 
         }, 
         it: function() { 
          stopIt(); 
         }, 
         this: function() { 
          stopThis(); 
         }, 
         that: function() { 
          stopThat(); 
         } 
        }; 
   
        var stopKeys = Object.keys(stopping); 
   
        function stopsOthers(doing) { 
         arr = stopKeys.filter(function(item) { 
          return item !== doing; 
         }); 
         arr.forEach(function(key) { 
          stopping[key](); 
         }); 
        } 
        stopsOthers(what); 
        doing[what]();