unicorn/consistent-function-scoping Suspicious

🚧 An auto-fix is still under development.

What it does

Disallow functions that are declared in a scope which does not capture any variables from the outer scope.

Why is this bad?

Moving function declarations to the highest possible scope improves readability, directly improves performance and allows JavaScript engines to better optimize your performance.

Examples

Examples of incorrect code for this rule:

export function doFoo(foo) {
  // Does not capture anything from the scope, can be moved to the outer scope
  function doBar(bar) {
    return bar === "bar";
  }
  return doBar;
}
function doFoo(foo) {
  const doBar = (bar) => {
    return bar === "bar";
  };
}

Examples of correct code for this rule:

function doBar(bar) {
  return bar === "bar";
}

export function doFoo(foo) {
  return doBar;
}

export function doFoo(foo) {
  function doBar(bar) {
    return bar === "bar" && foo.doBar(bar);
  }

  return doBar;
}

Options

checkArrowFunctions

Type: boolean
Default: true

Pass "checkArrowFunctions": false to disable linting of arrow functions.

Limitations

This rule does not detect or remove extraneous code blocks inside of functions:

function doFoo(foo) {
  {
    function doBar(bar) {
      return bar;
    }
  }

  return foo;
}

It also ignores functions that contain JSXElement references:

function doFoo(FooComponent) {
  function Bar() {
    return <FooComponent />;
  }

  return Bar;
}

Immediately invoked function expressions (IIFE) are ignored:

(function () {
  function doFoo(bar) {
    return bar;
  }
})();

References

• Rule Source