在 Javascript 中避免多个检查条件的最佳方法

Question

为了编写具有良好可读性的优质代码，我采用currying functions 方法，为大部分重复代码sn-ps 制作纯辅助函数。我刚刚观察到我的项目中到处都有存在/类型检查，以避免任何可能的错误，例如type of undefined.

检查如下：

if (param){
 action...
}

我正在考虑创建一个需要两个参数的全局辅助函数； param 需要检查，action function 在检查通过时执行操作。比如：

function isExist(param, action){
  if (param){
    action();
  }
}

此功能不适用于所有 sn-ps/案例。我怎样才能使它在所有情况下都高效且具有全局功能？这也是正确的方法。如果不是，那么我应该遵循什么来实现我的目标的最佳方法是什么？

示例：

if (userInput){
  saveToDB(userInput);
}
if (valueFromDB){
  performSomeAction();
}
if (username && password){
  validate(username, password)
}

我希望代码中不同点的所有这些检查都被单个辅助函数替换，有点像：

isExist( userInput, saveToDB(userInput) );
isExist( valueFromDB, performSomeAction );
isExist( (username && password), validate(username, password) );

通过这种方式，我们将这 9 行代码替换为仅 3 行代码。这就是我想要实现的目标。

Answer 1

好吧，如果你想一个好名字

function isExist(param, action){
  if (param){
    action();
  }
}

那么我认为一个好的候选人是conditionalExecute(condition, codeToExecute)。这种工作听起来是不是很熟悉？你确定你不只是重新发明 if 语句本身吗？

也许我没有理解你的意思，但我个人看不出将 if 语句的逻辑封装得比现在更多的好处。

编辑：需要注意的是，在 Javascript 上下文中的代码

if(someVariable){
  // do something
}

已经写成“如果someVariable 是truthy（undefined 不是）那么......

但是可以肯定的是，如果您只想检查是否存在（一个未定义的变量），如果您说最好有一个明确的命名函数，我不会反对您。

在这种情况下，我认为只封装实际存在检查（或您想要检查的内容）而不是条件性质（因为我们已经有了 if 语句）会更清楚。所以像

function exists(x) {
  return x !== undefined; // or something like that
}
function isNotNull(x) {
  //TODO:
}

然后你的代码会变得更加明确和可读，你可以根据需要组合功能

function neitherUndefinedNorNull(x){
   return exists(x) && isNotNull(x);
}

if(neitherUndefinedNorNull(X)){
  // your "regular" code here
}

如果 if 语句中的代码重复，则也将其提取为函数。

function myRepeatedCode() {
   // do stuff
}

function someAlternativeCondition(x){ 
  // test
}

if(neitherUndefinedNorNull ){
  myRepeatedCode();
} else if(someAlternativeCondition(x)) {
  myRepeatedCode();
}

// OR combine them in the same if-statement
if(neitherUndefinedNorNull(x) || someAlternativeCondition(x)){
  myRepeatedCode();
}

最后编辑：如果你在追字符，你甚至可以写

// because of short-circuiting, myFunc1 and myFunc2 will only
// execute if myCond1 resp myCond2  is true (or truthy).
myCond1(x) && myFunc1(x)
myCond2(y) && myFunc2(y)

Answer 2

这是使用Maybe的完美场所：

const enumerable = true;

// data Maybe a = Nothing | Just a

const Maybe   = {};
const Nothing = Object.create(Maybe);
const Just    = value => Object.create(Maybe, {value: {enumerable, value}});

// instance Functor Maybe where

Nothing.map = _ => Nothing;
Maybe.map = function (fun) { return Just(fun(this.value)); };

// instance Applicative Maybe where

Maybe.of = Just;
Nothing.ap = _ => Nothing;
Maybe.ap = function (maybe) { return maybe.map(this.value); };

// instance Monad Maybe where

Nothing.chain = _ => Nothing;
Maybe.chain = function (kleisli) { return kleisli(this.value); };

Maybe 遵循Fantasy Land Specification^[1]。使用Maybe 可以编写如下代码：

// userInput :: Maybe Data
// saveToDB  :: Data -> Something
userInput.map(saveToDB); // :: Maybe Something

// valueFromDB       :: Maybe Data
// performSomeAction :: Data -> Maybe Something
valueFromDB.chain(performSomeAction); // :: Maybe Something

// username :: Maybe String
// password :: Maybe Password
// validate :: String -> Password -> Something
Maybe.of(validate).ap(username).ap(password); // :: Maybe Something

无论如何，如果你真的对函数式编程感兴趣，那么我建议你Learn You A Haskell。

---

^[1] 我不同意 flipping the arguments of ap 上的 Fantasy Land 规范。

Answer 3

这样怎么样，可以同时处理参数。

function test(a,b,c)
{
    console.log("%s,%s,%s",a,b,c)
}

function check_and_run(param,action){
    var args = Array.prototype.slice.call(arguments); //turn arguments to array
    args.shift();  //remove param and action
    args.shift(); 
    if(param)
        action.apply(this,args)  
}


check_and_run(1,test,1,2,3)  //this will invoke test(1,2,3)
check_and_run(0,test,1,2,3)  //this will do nothing

Answer 4

大概是这样的：

function conFun(fnCondition, fnCall, defaultResult=undefined) {
  return (...rest) => {
    if( fnCondition(...rest) ) {
      return fnCall(...rest)
    }
    return defaultResult;
  }
}

const add = conFun(
   (...rest) => rest.every(n => typeof n === 'number'),
   (...rest) => rest.reduce((a, n) => a+n), 
   NaN);

add("1", "2"); //=> NaN
add(1, 2);     //=> 3

所以在您的问题中，您可能在第一个参数未定义之后：

const firstDefined = (v) => typeof v !== 'undefined';
const cSomeFun = conFun(firstDefined, someFun, "");

cSomeFun(); // ==> ""
cSomeFun("test"); // ==> whatever someFun("test") returns

如果您只是想根据未定义的参数调用某些东西，您可以像这样简单地定义它：

function callDefined(fn, ...rest) {
  if( rest.every(firstDefined) ) {
    return fn(...rest)
  }
  return undefined;
}

callDefined( saveToDB.bind(this, userInput), userInput);
callDefined( performSomeAction, valueFromDB);
callDefined( calidate.bind(this, username, password), username, password);