Sign upLogin

IHTSDO/component-identifier-service

View on GitHub
Star
blogic/CleanService.js

Summary

Maintainability
A
3 hrs
Test Coverage

Function cleanUpExpiredIds has 75 lines of code (exceeds 25 allowed). Consider refactoring.
Open

var cleanUpExpiredIds = function (callback){
    strErr="";
    strData="";
    strMsg="";
    var arrMsg=[];
Severity: Major
Found in blogic/CleanService.js - About 3 hrs to fix

    Function has a complexity of 8.
    Open

            function (err, data) {
    Severity: Minor
    Found in blogic/CleanService.js by eslint

    Limit Cyclomatic Complexity (complexity)

    Cyclomatic complexity measures the number of linearly independent paths through a program's source code. This rule allows setting a cyclomatic complexity threshold.

    function a(x) {
    if (true) {
        return x; // 1st path
    } else if (false) {
        return x+1; // 2nd path
    } else {
        return 4; // 3rd path
    }
}

    Rule Details

    This rule is aimed at reducing code complexity by capping the amount of cyclomatic complexity allowed in a program. As such, it will warn when the cyclomatic complexity crosses the configured threshold (default is 20).

    Examples of incorrect code for a maximum of 2:

    /*eslint complexity: ["error", 2]*/

function a(x) {
    if (true) {
        return x;
    } else if (false) {
        return x+1;
    } else {
        return 4; // 3rd path
    }
}

    Examples of correct code for a maximum of 2:

    /*eslint complexity: ["error", 2]*/

function a(x) {
    if (true) {
        return x;
    } else {
        return 4;
    }
}

    Options

    Optionally, you may specify a max object property:

    "complexity": ["error", 2]

    is equivalent to

    "complexity": ["error", { "max": 2 }]

    Deprecated: the object property maximum is deprecated. Please use the property max instead.

    When Not To Use It

    If you can't determine an appropriate complexity limit for your code, then it's best to disable this rule.

    Further Reading

    Related Rules

    • [max-depth](max-depth.md)
    • [max-len](max-len.md)
    • [max-nested-callbacks](max-nested-callbacks.md)
    • [max-params](max-params.md)
    • [max-statements](max-statements.md) Source: http://eslint.org/docs/rules/

    Function has a complexity of 8.
    Open

            function (err, data) {
    Severity: Minor
    Found in blogic/CleanService.js by eslint

    Limit Cyclomatic Complexity (complexity)

    Cyclomatic complexity measures the number of linearly independent paths through a program's source code. This rule allows setting a cyclomatic complexity threshold.

    function a(x) {
    if (true) {
        return x; // 1st path
    } else if (false) {
        return x+1; // 2nd path
    } else {
        return 4; // 3rd path
    }
}

    Rule Details

    This rule is aimed at reducing code complexity by capping the amount of cyclomatic complexity allowed in a program. As such, it will warn when the cyclomatic complexity crosses the configured threshold (default is 20).

    Examples of incorrect code for a maximum of 2:

    /*eslint complexity: ["error", 2]*/

function a(x) {
    if (true) {
        return x;
    } else if (false) {
        return x+1;
    } else {
        return 4; // 3rd path
    }
}

    Examples of correct code for a maximum of 2:

    /*eslint complexity: ["error", 2]*/

function a(x) {
    if (true) {
        return x;
    } else {
        return 4;
    }
}

    Options

    Optionally, you may specify a max object property:

    "complexity": ["error", 2]

    is equivalent to

    "complexity": ["error", { "max": 2 }]

    Deprecated: the object property maximum is deprecated. Please use the property max instead.

    When Not To Use It

    If you can't determine an appropriate complexity limit for your code, then it's best to disable this rule.

    Further Reading

    Related Rules

    • [max-depth](max-depth.md)
    • [max-len](max-len.md)
    • [max-nested-callbacks](max-nested-callbacks.md)
    • [max-params](max-params.md)
    • [max-statements](max-statements.md) Source: http://eslint.org/docs/rules/

    Expected return with your callback function.
    Open

                                callback(strMsg, null);
    Severity: Minor
    Found in blogic/CleanService.js by eslint

    Enforce Return After Callback (callback-return)

    The callback pattern is at the heart of most I/O and event-driven programming in JavaScript.

    function doSomething(err, callback) {
    if (err) {
        return callback(err);
    }
    callback();
}

    To prevent calling the callback multiple times it is important to return anytime the callback is triggered outside of the main function body. Neglecting this technique often leads to issues where you do something more than once. For example, in the case of an HTTP request, you may try to send HTTP headers more than once leading Node.js to throw a Can't render headers after they are sent to the client. error.

    Rule Details

    This rule is aimed at ensuring that callbacks used outside of the main function block are always part-of or immediately preceding a return statement. This rule decides what is a callback based on the name of the function being called.

    Options

    The rule takes a single option - an array of possible callback names - which may include object methods. The default callback names are callback, cb, next.

    Default callback names

    Examples of incorrect code for this rule with the default ["callback", "cb", "next"] option:

    /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        callback(err);
    }
    callback();
}

    Examples of correct code for this rule with the default ["callback", "cb", "next"] option:

    /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        return callback(err);
    }
    callback();
}

    Supplied callback names

    Examples of incorrect code for this rule with the option ["done", "send.error", "send.success"]:

    /*eslint callback-return: ["error", ["done", "send.error", "send.success"]]*/

function foo(err, done) {
    if (err) {
        done(err);
    }
    done();
}

function bar(err, send) {
    if (err) {
        send.error(err);
    }
    send.success();
}

    Examples of correct code for this rule with the option ["done", "send.error", "send.success"]:

    /*eslint callback-return: ["error", ["done", "send.error", "send.success"]]*/

function foo(err, done) {
    if (err) {
        return done(err);
    }
    done();
}

function bar(err, send) {
    if (err) {
        return send.error(err);
    }
    send.success();
}

    Known Limitations

    Because it is difficult to understand the meaning of a program through static analysis, this rule has limitations:

    • false negatives when this rule reports correct code, but the program calls the callback more than one time (which is incorrect behavior)
    • false positives when this rule reports incorrect code, but the program calls the callback only one time (which is correct behavior)

    Passing the callback by reference

    The static analysis of this rule does not detect that the program calls the callback if it is an argument of a function (for example, setTimeout).

    Example of a false negative when this rule reports correct code:

    /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        setTimeout(callback, 0); // this is bad, but WILL NOT warn
    }
    callback();
}

    Triggering the callback within a nested function

    The static analysis of this rule does not detect that the program calls the callback from within a nested function or an immediately-invoked function expression (IIFE).

    Example of a false negative when this rule reports correct code:

    /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        process.nextTick(function() {
            return callback(); // this is bad, but WILL NOT warn
        });
    }
    callback();
}

    If/else statements

    The static analysis of this rule does not detect that the program calls the callback only one time in each branch of an if statement.

    Example of a false positive when this rule reports incorrect code:

    /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        callback(err); // this is fine, but WILL warn
    } else {
        callback();    // this is fine, but WILL warn
    }
}

    When Not To Use It

    There are some cases where you might want to call a callback function more than once. In those cases this rule may lead to incorrect behavior. In those cases you may want to reserve a special name for those callbacks and not include that in the list of callbacks that trigger warnings.

    Further Reading

    Related Rules

    Expected return with your callback function.
    Open

                                callback(strMsg, null);
    Severity: Minor
    Found in blogic/CleanService.js by eslint

    Enforce Return After Callback (callback-return)

    The callback pattern is at the heart of most I/O and event-driven programming in JavaScript.

    function doSomething(err, callback) {
    if (err) {
        return callback(err);
    }
    callback();
}

    To prevent calling the callback multiple times it is important to return anytime the callback is triggered outside of the main function body. Neglecting this technique often leads to issues where you do something more than once. For example, in the case of an HTTP request, you may try to send HTTP headers more than once leading Node.js to throw a Can't render headers after they are sent to the client. error.

    Rule Details

    This rule is aimed at ensuring that callbacks used outside of the main function block are always part-of or immediately preceding a return statement. This rule decides what is a callback based on the name of the function being called.

    Options

    The rule takes a single option - an array of possible callback names - which may include object methods. The default callback names are callback, cb, next.

    Default callback names

    Examples of incorrect code for this rule with the default ["callback", "cb", "next"] option:

    /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        callback(err);
    }
    callback();
}

    Examples of correct code for this rule with the default ["callback", "cb", "next"] option:

    /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        return callback(err);
    }
    callback();
}

    Supplied callback names

    Examples of incorrect code for this rule with the option ["done", "send.error", "send.success"]:

    /*eslint callback-return: ["error", ["done", "send.error", "send.success"]]*/

function foo(err, done) {
    if (err) {
        done(err);
    }
    done();
}

function bar(err, send) {
    if (err) {
        send.error(err);
    }
    send.success();
}

    Examples of correct code for this rule with the option ["done", "send.error", "send.success"]:

    /*eslint callback-return: ["error", ["done", "send.error", "send.success"]]*/

function foo(err, done) {
    if (err) {
        return done(err);
    }
    done();
}

function bar(err, send) {
    if (err) {
        return send.error(err);
    }
    send.success();
}

    Known Limitations

    Because it is difficult to understand the meaning of a program through static analysis, this rule has limitations:

    • false negatives when this rule reports correct code, but the program calls the callback more than one time (which is incorrect behavior)
    • false positives when this rule reports incorrect code, but the program calls the callback only one time (which is correct behavior)

    Passing the callback by reference

    The static analysis of this rule does not detect that the program calls the callback if it is an argument of a function (for example, setTimeout).

    Example of a false negative when this rule reports correct code:

    /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        setTimeout(callback, 0); // this is bad, but WILL NOT warn
    }
    callback();
}

    Triggering the callback within a nested function

    The static analysis of this rule does not detect that the program calls the callback from within a nested function or an immediately-invoked function expression (IIFE).

    Example of a false negative when this rule reports correct code:

    /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        process.nextTick(function() {
            return callback(); // this is bad, but WILL NOT warn
        });
    }
    callback();
}

    If/else statements

    The static analysis of this rule does not detect that the program calls the callback only one time in each branch of an if statement.

    Example of a false positive when this rule reports incorrect code:

    /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        callback(err); // this is fine, but WILL warn
    } else {
        callback();    // this is fine, but WILL warn
    }
}

    When Not To Use It

    There are some cases where you might want to call a callback function more than once. In those cases this rule may lead to incorrect behavior. In those cases you may want to reserve a special name for those callbacks and not include that in the list of callbacks that trigger warnings.

    Further Reading

    Related Rules

    Expected return with your callback function.
    Open

                            callback(strMsg, null);
    Severity: Minor
    Found in blogic/CleanService.js by eslint

    Enforce Return After Callback (callback-return)

    The callback pattern is at the heart of most I/O and event-driven programming in JavaScript.

    function doSomething(err, callback) {
    if (err) {
        return callback(err);
    }
    callback();
}

    To prevent calling the callback multiple times it is important to return anytime the callback is triggered outside of the main function body. Neglecting this technique often leads to issues where you do something more than once. For example, in the case of an HTTP request, you may try to send HTTP headers more than once leading Node.js to throw a Can't render headers after they are sent to the client. error.

    Rule Details

    This rule is aimed at ensuring that callbacks used outside of the main function block are always part-of or immediately preceding a return statement. This rule decides what is a callback based on the name of the function being called.

    Options

    The rule takes a single option - an array of possible callback names - which may include object methods. The default callback names are callback, cb, next.

    Default callback names

    Examples of incorrect code for this rule with the default ["callback", "cb", "next"] option:

    /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        callback(err);
    }
    callback();
}

    Examples of correct code for this rule with the default ["callback", "cb", "next"] option:

    /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        return callback(err);
    }
    callback();
}

    Supplied callback names

    Examples of incorrect code for this rule with the option ["done", "send.error", "send.success"]:

    /*eslint callback-return: ["error", ["done", "send.error", "send.success"]]*/

function foo(err, done) {
    if (err) {
        done(err);
    }
    done();
}

function bar(err, send) {
    if (err) {
        send.error(err);
    }
    send.success();
}

    Examples of correct code for this rule with the option ["done", "send.error", "send.success"]:

    /*eslint callback-return: ["error", ["done", "send.error", "send.success"]]*/

function foo(err, done) {
    if (err) {
        return done(err);
    }
    done();
}

function bar(err, send) {
    if (err) {
        return send.error(err);
    }
    send.success();
}

    Known Limitations

    Because it is difficult to understand the meaning of a program through static analysis, this rule has limitations:

    • false negatives when this rule reports correct code, but the program calls the callback more than one time (which is incorrect behavior)
    • false positives when this rule reports incorrect code, but the program calls the callback only one time (which is correct behavior)

    Passing the callback by reference

    The static analysis of this rule does not detect that the program calls the callback if it is an argument of a function (for example, setTimeout).

    Example of a false negative when this rule reports correct code:

    /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        setTimeout(callback, 0); // this is bad, but WILL NOT warn
    }
    callback();
}

    Triggering the callback within a nested function

    The static analysis of this rule does not detect that the program calls the callback from within a nested function or an immediately-invoked function expression (IIFE).

    Example of a false negative when this rule reports correct code:

    /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        process.nextTick(function() {
            return callback(); // this is bad, but WILL NOT warn
        });
    }
    callback();
}

    If/else statements

    The static analysis of this rule does not detect that the program calls the callback only one time in each branch of an if statement.

    Example of a false positive when this rule reports incorrect code:

    /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        callback(err); // this is fine, but WILL warn
    } else {
        callback();    // this is fine, but WILL warn
    }
}

    When Not To Use It

    There are some cases where you might want to call a callback function more than once. In those cases this rule may lead to incorrect behavior. In those cases you may want to reserve a special name for those callbacks and not include that in the list of callbacks that trigger warnings.

    Further Reading

    Related Rules

    Expected '===' and instead saw '=='.
    Open

                            if (strErr=="") {
    Severity: Minor
    Found in blogic/CleanService.js by eslint

    Require === and !== (eqeqeq)

    It is considered good practice to use the type-safe equality operators === and !== instead of their regular counterparts == and !=.

    The reason for this is that == and != do type coercion which follows the rather obscure Abstract Equality Comparison Algorithm. For instance, the following statements are all considered true:

    • [] == false
    • [] == ![]
    • 3 == "03"

    If one of those occurs in an innocent-looking statement such as a == b the actual problem is very difficult to spot.

    Rule Details

    This rule is aimed at eliminating the type-unsafe equality operators.

    Examples of incorrect code for this rule:

    /*eslint eqeqeq: "error"*/

if (x == 42) { }

if ("" == text) { }

if (obj.getStuff() != undefined) { }

    The --fix option on the command line automatically fixes some problems reported by this rule. A problem is only fixed if one of the operands is a typeof expression, or if both operands are literals with the same type.

    Options

    always

    The "always" option (default) enforces the use of === and !== in every situation (except when you opt-in to more specific handling of null [see below]).

    Examples of incorrect code for the "always" option:

    /*eslint eqeqeq: ["error", "always"]*/

a == b
foo == true
bananas != 1
value == undefined
typeof foo == 'undefined'
'hello' != 'world'
0 == 0
true == true
foo == null

    Examples of correct code for the "always" option:

    /*eslint eqeqeq: ["error", "always"]*/

a === b
foo === true
bananas !== 1
value === undefined
typeof foo === 'undefined'
'hello' !== 'world'
0 === 0
true === true
foo === null

    This rule optionally takes a second argument, which should be an object with the following supported properties:

    • "null": Customize how this rule treats null literals. Possible values:
      • always (default) - Always use === or !==.
      • never - Never use === or !== with null.
      • ignore - Do not apply this rule to null.

    smart

    The "smart" option enforces the use of === and !== except for these cases:

    • Comparing two literal values
    • Evaluating the value of typeof
    • Comparing against null

    Examples of incorrect code for the "smart" option:

    /*eslint eqeqeq: ["error", "smart"]*/

// comparing two variables requires ===
a == b

// only one side is a literal
foo == true
bananas != 1

// comparing to undefined requires ===
value == undefined

    Examples of correct code for the "smart" option:

    /*eslint eqeqeq: ["error", "smart"]*/

typeof foo == 'undefined'
'hello' != 'world'
0 == 0
true == true
foo == null

    allow-null

    Deprecated: Instead of using this option use "always" and pass a "null" option property with value "ignore". This will tell eslint to always enforce strict equality except when comparing with the null literal.

    ["error", "always", {"null": "ignore"}]

    When Not To Use It

    If you don't want to enforce a style for using equality operators, then it's safe to disable this rule. Source: http://eslint.org/docs/rules/

    Expected return with your callback function.
    Open

                                callback( null,arrMsg);
    Severity: Minor
    Found in blogic/CleanService.js by eslint

    Enforce Return After Callback (callback-return)

    The callback pattern is at the heart of most I/O and event-driven programming in JavaScript.

    function doSomething(err, callback) {
    if (err) {
        return callback(err);
    }
    callback();
}

    To prevent calling the callback multiple times it is important to return anytime the callback is triggered outside of the main function body. Neglecting this technique often leads to issues where you do something more than once. For example, in the case of an HTTP request, you may try to send HTTP headers more than once leading Node.js to throw a Can't render headers after they are sent to the client. error.

    Rule Details

    This rule is aimed at ensuring that callbacks used outside of the main function block are always part-of or immediately preceding a return statement. This rule decides what is a callback based on the name of the function being called.

    Options

    The rule takes a single option - an array of possible callback names - which may include object methods. The default callback names are callback, cb, next.

    Default callback names

    Examples of incorrect code for this rule with the default ["callback", "cb", "next"] option:

    /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        callback(err);
    }
    callback();
}

    Examples of correct code for this rule with the default ["callback", "cb", "next"] option:

    /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        return callback(err);
    }
    callback();
}

    Supplied callback names

    Examples of incorrect code for this rule with the option ["done", "send.error", "send.success"]:

    /*eslint callback-return: ["error", ["done", "send.error", "send.success"]]*/

function foo(err, done) {
    if (err) {
        done(err);
    }
    done();
}

function bar(err, send) {
    if (err) {
        send.error(err);
    }
    send.success();
}

    Examples of correct code for this rule with the option ["done", "send.error", "send.success"]:

    /*eslint callback-return: ["error", ["done", "send.error", "send.success"]]*/

function foo(err, done) {
    if (err) {
        return done(err);
    }
    done();
}

function bar(err, send) {
    if (err) {
        return send.error(err);
    }
    send.success();
}

    Known Limitations

    Because it is difficult to understand the meaning of a program through static analysis, this rule has limitations:

    • false negatives when this rule reports correct code, but the program calls the callback more than one time (which is incorrect behavior)
    • false positives when this rule reports incorrect code, but the program calls the callback only one time (which is correct behavior)

    Passing the callback by reference

    The static analysis of this rule does not detect that the program calls the callback if it is an argument of a function (for example, setTimeout).

    Example of a false negative when this rule reports correct code:

    /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        setTimeout(callback, 0); // this is bad, but WILL NOT warn
    }
    callback();
}

    Triggering the callback within a nested function

    The static analysis of this rule does not detect that the program calls the callback from within a nested function or an immediately-invoked function expression (IIFE).

    Example of a false negative when this rule reports correct code:

    /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        process.nextTick(function() {
            return callback(); // this is bad, but WILL NOT warn
        });
    }
    callback();
}

    If/else statements

    The static analysis of this rule does not detect that the program calls the callback only one time in each branch of an if statement.

    Example of a false positive when this rule reports incorrect code:

    /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        callback(err); // this is fine, but WILL warn
    } else {
        callback();    // this is fine, but WILL warn
    }
}

    When Not To Use It

    There are some cases where you might want to call a callback function more than once. In those cases this rule may lead to incorrect behavior. In those cases you may want to reserve a special name for those callbacks and not include that in the list of callbacks that trigger warnings.

    Further Reading

    Related Rules

    Expected return with your callback function.
    Open

                            callback(strMsg, null);
    Severity: Minor
    Found in blogic/CleanService.js by eslint

    Enforce Return After Callback (callback-return)

    The callback pattern is at the heart of most I/O and event-driven programming in JavaScript.

    function doSomething(err, callback) {
    if (err) {
        return callback(err);
    }
    callback();
}

    To prevent calling the callback multiple times it is important to return anytime the callback is triggered outside of the main function body. Neglecting this technique often leads to issues where you do something more than once. For example, in the case of an HTTP request, you may try to send HTTP headers more than once leading Node.js to throw a Can't render headers after they are sent to the client. error.

    Rule Details

    This rule is aimed at ensuring that callbacks used outside of the main function block are always part-of or immediately preceding a return statement. This rule decides what is a callback based on the name of the function being called.

    Options

    The rule takes a single option - an array of possible callback names - which may include object methods. The default callback names are callback, cb, next.

    Default callback names

    Examples of incorrect code for this rule with the default ["callback", "cb", "next"] option:

    /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        callback(err);
    }
    callback();
}

    Examples of correct code for this rule with the default ["callback", "cb", "next"] option:

    /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        return callback(err);
    }
    callback();
}

    Supplied callback names

    Examples of incorrect code for this rule with the option ["done", "send.error", "send.success"]:

    /*eslint callback-return: ["error", ["done", "send.error", "send.success"]]*/

function foo(err, done) {
    if (err) {
        done(err);
    }
    done();
}

function bar(err, send) {
    if (err) {
        send.error(err);
    }
    send.success();
}

    Examples of correct code for this rule with the option ["done", "send.error", "send.success"]:

    /*eslint callback-return: ["error", ["done", "send.error", "send.success"]]*/

function foo(err, done) {
    if (err) {
        return done(err);
    }
    done();
}

function bar(err, send) {
    if (err) {
        return send.error(err);
    }
    send.success();
}

    Known Limitations

    Because it is difficult to understand the meaning of a program through static analysis, this rule has limitations:

    • false negatives when this rule reports correct code, but the program calls the callback more than one time (which is incorrect behavior)
    • false positives when this rule reports incorrect code, but the program calls the callback only one time (which is correct behavior)

    Passing the callback by reference

    The static analysis of this rule does not detect that the program calls the callback if it is an argument of a function (for example, setTimeout).

    Example of a false negative when this rule reports correct code:

    /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        setTimeout(callback, 0); // this is bad, but WILL NOT warn
    }
    callback();
}

    Triggering the callback within a nested function

    The static analysis of this rule does not detect that the program calls the callback from within a nested function or an immediately-invoked function expression (IIFE).

    Example of a false negative when this rule reports correct code:

    /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        process.nextTick(function() {
            return callback(); // this is bad, but WILL NOT warn
        });
    }
    callback();
}

    If/else statements

    The static analysis of this rule does not detect that the program calls the callback only one time in each branch of an if statement.

    Example of a false positive when this rule reports incorrect code:

    /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        callback(err); // this is fine, but WILL warn
    } else {
        callback();    // this is fine, but WILL warn
    }
}

    When Not To Use It

    There are some cases where you might want to call a callback function more than once. In those cases this rule may lead to incorrect behavior. In those cases you may want to reserve a special name for those callbacks and not include that in the list of callbacks that trigger warnings.

    Further Reading

    Related Rules

    Expected '===' and instead saw '=='.
    Open

                            if (strErr=="") {
    Severity: Minor
    Found in blogic/CleanService.js by eslint

    Require === and !== (eqeqeq)

    It is considered good practice to use the type-safe equality operators === and !== instead of their regular counterparts == and !=.

    The reason for this is that == and != do type coercion which follows the rather obscure Abstract Equality Comparison Algorithm. For instance, the following statements are all considered true:

    • [] == false
    • [] == ![]
    • 3 == "03"

    If one of those occurs in an innocent-looking statement such as a == b the actual problem is very difficult to spot.

    Rule Details

    This rule is aimed at eliminating the type-unsafe equality operators.

    Examples of incorrect code for this rule:

    /*eslint eqeqeq: "error"*/

if (x == 42) { }

if ("" == text) { }

if (obj.getStuff() != undefined) { }

    The --fix option on the command line automatically fixes some problems reported by this rule. A problem is only fixed if one of the operands is a typeof expression, or if both operands are literals with the same type.

    Options

    always

    The "always" option (default) enforces the use of === and !== in every situation (except when you opt-in to more specific handling of null [see below]).

    Examples of incorrect code for the "always" option:

    /*eslint eqeqeq: ["error", "always"]*/

a == b
foo == true
bananas != 1
value == undefined
typeof foo == 'undefined'
'hello' != 'world'
0 == 0
true == true
foo == null

    Examples of correct code for the "always" option:

    /*eslint eqeqeq: ["error", "always"]*/

a === b
foo === true
bananas !== 1
value === undefined
typeof foo === 'undefined'
'hello' !== 'world'
0 === 0
true === true
foo === null

    This rule optionally takes a second argument, which should be an object with the following supported properties:

    • "null": Customize how this rule treats null literals. Possible values:
      • always (default) - Always use === or !==.
      • never - Never use === or !== with null.
      • ignore - Do not apply this rule to null.

    smart

    The "smart" option enforces the use of === and !== except for these cases:

    • Comparing two literal values
    • Evaluating the value of typeof
    • Comparing against null

    Examples of incorrect code for the "smart" option:

    /*eslint eqeqeq: ["error", "smart"]*/

// comparing two variables requires ===
a == b

// only one side is a literal
foo == true
bananas != 1

// comparing to undefined requires ===
value == undefined

    Examples of correct code for the "smart" option:

    /*eslint eqeqeq: ["error", "smart"]*/

typeof foo == 'undefined'
'hello' != 'world'
0 == 0
true == true
foo == null

    allow-null

    Deprecated: Instead of using this option use "always" and pass a "null" option property with value "ignore". This will tell eslint to always enforce strict equality except when comparing with the null literal.

    ["error", "always", {"null": "ignore"}]

    When Not To Use It

    If you don't want to enforce a style for using equality operators, then it's safe to disable this rule. Source: http://eslint.org/docs/rules/

    Expected return with your callback function.
    Open

                                callback( null,arrMsg);
    Severity: Minor
    Found in blogic/CleanService.js by eslint

    Enforce Return After Callback (callback-return)

    The callback pattern is at the heart of most I/O and event-driven programming in JavaScript.

    function doSomething(err, callback) {
    if (err) {
        return callback(err);
    }
    callback();
}

    To prevent calling the callback multiple times it is important to return anytime the callback is triggered outside of the main function body. Neglecting this technique often leads to issues where you do something more than once. For example, in the case of an HTTP request, you may try to send HTTP headers more than once leading Node.js to throw a Can't render headers after they are sent to the client. error.

    Rule Details

    This rule is aimed at ensuring that callbacks used outside of the main function block are always part-of or immediately preceding a return statement. This rule decides what is a callback based on the name of the function being called.

    Options

    The rule takes a single option - an array of possible callback names - which may include object methods. The default callback names are callback, cb, next.

    Default callback names

    Examples of incorrect code for this rule with the default ["callback", "cb", "next"] option:

    /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        callback(err);
    }
    callback();
}

    Examples of correct code for this rule with the default ["callback", "cb", "next"] option:

    /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        return callback(err);
    }
    callback();
}

    Supplied callback names

    Examples of incorrect code for this rule with the option ["done", "send.error", "send.success"]:

    /*eslint callback-return: ["error", ["done", "send.error", "send.success"]]*/

function foo(err, done) {
    if (err) {
        done(err);
    }
    done();
}

function bar(err, send) {
    if (err) {
        send.error(err);
    }
    send.success();
}

    Examples of correct code for this rule with the option ["done", "send.error", "send.success"]:

    /*eslint callback-return: ["error", ["done", "send.error", "send.success"]]*/

function foo(err, done) {
    if (err) {
        return done(err);
    }
    done();
}

function bar(err, send) {
    if (err) {
        return send.error(err);
    }
    send.success();
}

    Known Limitations

    Because it is difficult to understand the meaning of a program through static analysis, this rule has limitations:

    • false negatives when this rule reports correct code, but the program calls the callback more than one time (which is incorrect behavior)
    • false positives when this rule reports incorrect code, but the program calls the callback only one time (which is correct behavior)

    Passing the callback by reference

    The static analysis of this rule does not detect that the program calls the callback if it is an argument of a function (for example, setTimeout).

    Example of a false negative when this rule reports correct code:

    /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        setTimeout(callback, 0); // this is bad, but WILL NOT warn
    }
    callback();
}

    Triggering the callback within a nested function

    The static analysis of this rule does not detect that the program calls the callback from within a nested function or an immediately-invoked function expression (IIFE).

    Example of a false negative when this rule reports correct code:

    /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        process.nextTick(function() {
            return callback(); // this is bad, but WILL NOT warn
        });
    }
    callback();
}

    If/else statements

    The static analysis of this rule does not detect that the program calls the callback only one time in each branch of an if statement.

    Example of a false positive when this rule reports incorrect code:

    /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        callback(err); // this is fine, but WILL warn
    } else {
        callback();    // this is fine, but WILL warn
    }
}

    When Not To Use It

    There are some cases where you might want to call a callback function more than once. In those cases this rule may lead to incorrect behavior. In those cases you may want to reserve a special name for those callbacks and not include that in the list of callbacks that trigger warnings.

    Further Reading

    Related Rules

    There are no issues that match your filters.

    Category
    Status