如何在当前的JavaScript代码段中“返回此”以满足调用者的链接而不会破坏我的ESLint规则？

Question

I have the following code. It works perfectly and the caller needs each part to return this due to chaining:

module.exports = function(res){
return {
    success: function(content, contentType, resultCode) {
        sendResponse(
            res,
            content,
            validateContentType(contentType),
            validateResultCode(resultCode||'ok')
        )
        return this
    },
    error: function(resultCode, content, contentType){
        sendResponse(
            res,
            content,
            validateContentType(contentType),
            validateResultCode(resultCode||'bad_request')
        )
        return this
    },
    end: function(callback){
        res.end()
        callback&&callback()
        return this
    }
}
}

The thing is that I need my code to pass a set of ESLint rules. The above fails with the following, where line 36 is the first line of code:

36:18  warning  Unexpected unnamed function                                            func-names
36:26  error    Missing space before function parentheses                              space-before-function-paren
36:31  error    Missing space before opening brace                                     space-before-blocks
38:12  warning  Unexpected unnamed method 'success'                                    func-names
38:20  error    Missing space before function parentheses                              space-before-function-paren
43:34  error    Infix operators must be spaced                                         space-infix-ops
43:41  error    Missing trailing comma                                                 comma-dangle
44:5   error    Missing semicolon                                                      semi
45:15  error    Missing semicolon                                                      semi
47:10  warning  Unexpected unnamed method 'error'                                      func-names
47:18  error    Missing space before function parentheses                              space-before-function-paren
47:52  error    Missing space before opening brace                                     space-before-blocks
52:34  error    Infix operators must be spaced                                         space-infix-ops
52:50  error    Missing trailing comma                                                 comma-dangle
53:5   error    Missing semicolon                                                      semi
54:15  error    Missing semicolon                                                      semi
56:8   warning  Unexpected unnamed method 'end'                                        func-names
56:16  error    Missing space before function parentheses                              space-before-function-paren
56:26  error    Missing space before opening brace                                     space-before-blocks
57:13  error    Missing semicolon                                                      semi
58:4   error    Expected an assignment or function call and instead saw an expression  no-unused-expressions
58:12  error    Infix operators must be spaced                                         space-infix-ops
58:24  error    Missing semicolon                                                      semi
59:15  error    Missing semicolon                                                      semi
60:4   error    Missing trailing comma                                                 comma-dangle
61:3   error    Missing semicolon                                                      semi
62:2   error    Missing semicolon                                                      semi

The following snippet passes the rules but does NOT return this since that would give another ESLint error due to the no-invalid-this rule and critically, no longer works, breaking the chaining:

module.exports = res => ({
success: (content, contentType, resultCode) => {
    sendResponse(
        res,
        content,
        validateContentType(contentType),
        validateResultCode(resultCode || 'ok'),
    );
},
error: (resultCode, content, contentType) => {
    sendResponse(
        res,
        content,
        validateContentType(contentType),
        validateResultCode(resultCode || 'bad_request'),
    );
},
end: (callback) => {
    res.end();
    if (callback) {
        callback();
        return undefined;
    }
    return undefined;
},
});

My question is how do I adapt the second snippet (or indeed the first) to be functionally identical to the first but still pass the ESLint rules? How can I return correctly to allow chaining with the caller?

My .eslintrc.json :

{
  "extends": "airbnb-base",
 "rules": {
// use tabs, not spaces, and in switch statements the case statement should indent again (the default is to be level with the switch)
    "indent": [ "error", "tab", { "SwitchCase": 1 } ],
// if you want to put a blank line at the beginning or end of a block, knock yourself out
"padded-blocks": [ "off" ],
// i like tabs. besides, we set indent to require them
"no-tabs": [ "off" ],
// seriously, who cares if there's a blank line at the end of the file or not?
"eol-last": [ "off" ],
// sometimes having a long single line makes sense, this also seems buggy and inconsistent, so we ignore it
"max-len": [ "off" ],
// webstorm repeatedly tries to add it for us. it's easier not to fight it, even if it's not required.
"strict": [ "off" ],
// when setting the property of an object, you can specify the name even if it's unnecessary (ie: { foo: foo })
"object-shorthand": [ "off" ],
// unused vars are an error, except for function arguments.
// particularly with callbacks we may not use all the args, but we still like knowing they're available
"no-unused-vars": [ "error", { "vars": "all", "args": "none", "ignoreRestSiblings": true } ],
// you don't have to use operator assignment if you don't want to
"operator-assignment": [ "warn" ],
// we don't want else to be on the same line as the closing } of an if statement
"brace-style": [ "error", "stroustrup" ],
// warn about overly complex code that you may want to refactor
"complexity": [ "warn", 15 ],
// it's possible that implicit coercion is not what you intended. webstorm warns about it, so should we
"no-implicit-coercion": [ "warn" ],
// if you're using 'this' somewhere that isn't a class you're probably doing something wrong
"no-invalid-this": [ "error" ],
// if you're not modifying the variable used in a loop condition, you've probably done something wrong...
"no-unmodified-loop-condition": [ "warn" ],
// don't use .call or .apply when you don't need to
"no-useless-call": [ "warn" ],
// we want to slap you if you don't update your jsdoc, but not necessarily break one of your fingers
"valid-jsdoc": [ "warn" ],
// forgetting to return after calling a callback is an easy mistake to make, so we'll warn you if you are
"callback-return": [ "warn" ]
  }
}

Answer 1

Well as the docs of the eslint rules mentions , you need to give your anonymous function expressions a name (so they won't be anonymous anymore).
By the way this is good practice because you can debug it better and call it as a recursive function if you need.

Then why not just give them names?

module.exports = function exports(res) {
  return {
    success: function success(content, contentType, resultCode) {
      sendResponse(
        res,
        content,
        validateContentType(contentType),
        validateResultCode(resultCode || 'ok'),
      );
      return this;
    },
    error: function error(resultCode, content, contentType) {
      sendResponse(
        res,
        content,
        validateContentType(contentType),
        validateResultCode(resultCode || 'bad_request'),
      );
      return this;
    },
    end: function end(callback) {
      res.end();
      if (callback) {
        callback();
        return undefined;
      }
      return this;
    },
  }
}

Answer 2

I settled for a third snippet that is functionally equivalent to the first and has no ESLint errors but only ESLint warnings:

module.exports = function (res) {
return {
    success: function (content, contentType, resultCode) {
        sendResponse(
            res,
            content,
            validateContentType(contentType),
            validateResultCode(resultCode || 'ok'),
        );
        return this;
    },
    error: function (resultCode, content, contentType) {
        sendResponse(
            res,
            content,
            validateContentType(contentType),
            validateResultCode(resultCode || 'bad_request'),
        );
        return this;
    },
    end: function (callback) {
        res.end();
        if (callback) {
            callback();
            return undefined;
        }
        return this;
    },
};

};

  36:18  warning  Unexpected unnamed function          func-names
  38:12  warning  Unexpected unnamed method 'success'  func-names
  47:10  warning  Unexpected unnamed method 'error'    func-names
  56:8   warning  Unexpected unnamed method 'end'      func-names

However, if someone would care to adapt snippet 2 in my question to work as though it 'returned this', passing my ESLint errors, warnings and being functionally equivalent to snippet 1 or my answer then I will mark that answer as correct!

Answer 3

I'll guess you are supposed to use method syntax for your methods, instead function expressions:

module.exports = (res) => ({
    success(content, contentType, resultCode) {
        sendResponse(
            res,
            content,
            validateContentType(contentType),
            validateResultCode(resultCode || 'ok'),
        );
        return this;
    },
    error(resultCode, content, contentType) {
        sendResponse(
            res,
            content,
            validateContentType(contentType),
            validateResultCode(resultCode || 'bad_request'),
        );
        return this;
    },
    end(callback) {
        res.end();
        if (callback) {
            callback();
        }
        return this;
    },
});