Function _defineGettersSetters
has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring. Open
static _defineGettersSetters(constructor) {
const schema = constructor.SCHEMA;
if (schema && schema.properties) {
// eslint-disable-next-line no-restricted-syntax
for (const key in schema.properties) {
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Expected 'this' to be used by class method 'accessor'. Open
accessor() {
- Read upRead up
- Exclude checks
Enforce that class methods utilize this
(class-methods-use-this)
If a class method does not use this
, it can safely be made a static function.
It's possible to have a class method which doesn't use this
, such as:
class A {
constructor() {
this.a = "hi";
}
print() {
console.log(this.a);
}
sayHi() {
console.log("hi");
}
}
let a = new A();
a.sayHi(); // => "hi"
In the example above, the sayHi
method doesn't use this
, so we can make it a static method:
class A {
constructor() {
this.a = "hi";
}
print() {
console.log(this.a);
}
static sayHi() {
console.log("hi");
}
}
A.sayHi(); // => "hi"
Also note in the above examples that the code calling the function on an instance of the class (let a = new A(); a.sayHi();
) changes to calling it on the class itself (A.sayHi();
).
Rule Details
This rule is aimed to flag class methods that do not use this
.
Examples of incorrect code for this rule:
/*eslint class-methods-use-this: "error"*/
/*eslint-env es6*/
class A {
foo() {
console.log("Hello World"); /*error Expected 'this' to be used by class method 'foo'.*/
}
}
Examples of correct code for this rule:
/*eslint class-methods-use-this: "error"*/
/*eslint-env es6*/
class A {
foo() {
this.bar = "Hello World"; // OK, this is used
}
}
class A {
constructor() {
// OK. constructor is exempt
}
}
class A {
static foo() {
// OK. static methods aren't expected to use this.
}
}
Options
Exceptions
"class-methods-use-this": [<enabled>, { "exceptMethods": [<...exceptions>] }]</enabled>
The exceptMethods
option allows you to pass an array of method names for which you would like to ignore warnings.
Examples of incorrect code for this rule when used without exceptMethods:
/*eslint class-methods-use-this: "error"*/
class A {
foo() {
}
}
Examples of correct code for this rule when used with exceptMethods:
/*eslint class-methods-use-this: ["error", { "exceptMethods": ["foo"] }] */
class A {
foo() {
}
}
Source: http://eslint.org/docs/rules/
Expected 'this' to be used by class method 'mutator'. Open
mutator() {
- Read upRead up
- Exclude checks
Enforce that class methods utilize this
(class-methods-use-this)
If a class method does not use this
, it can safely be made a static function.
It's possible to have a class method which doesn't use this
, such as:
class A {
constructor() {
this.a = "hi";
}
print() {
console.log(this.a);
}
sayHi() {
console.log("hi");
}
}
let a = new A();
a.sayHi(); // => "hi"
In the example above, the sayHi
method doesn't use this
, so we can make it a static method:
class A {
constructor() {
this.a = "hi";
}
print() {
console.log(this.a);
}
static sayHi() {
console.log("hi");
}
}
A.sayHi(); // => "hi"
Also note in the above examples that the code calling the function on an instance of the class (let a = new A(); a.sayHi();
) changes to calling it on the class itself (A.sayHi();
).
Rule Details
This rule is aimed to flag class methods that do not use this
.
Examples of incorrect code for this rule:
/*eslint class-methods-use-this: "error"*/
/*eslint-env es6*/
class A {
foo() {
console.log("Hello World"); /*error Expected 'this' to be used by class method 'foo'.*/
}
}
Examples of correct code for this rule:
/*eslint class-methods-use-this: "error"*/
/*eslint-env es6*/
class A {
foo() {
this.bar = "Hello World"; // OK, this is used
}
}
class A {
constructor() {
// OK. constructor is exempt
}
}
class A {
static foo() {
// OK. static methods aren't expected to use this.
}
}
Options
Exceptions
"class-methods-use-this": [<enabled>, { "exceptMethods": [<...exceptions>] }]</enabled>
The exceptMethods
option allows you to pass an array of method names for which you would like to ignore warnings.
Examples of incorrect code for this rule when used without exceptMethods:
/*eslint class-methods-use-this: "error"*/
class A {
foo() {
}
}
Examples of correct code for this rule when used with exceptMethods:
/*eslint class-methods-use-this: ["error", { "exceptMethods": ["foo"] }] */
class A {
foo() {
}
}
Source: http://eslint.org/docs/rules/
Do not access Object.prototype method 'hasOwnProperty' from target object. Open
if (!constructor.prototype.hasOwnProperty(key)) {
- Read upRead up
- Exclude checks
Disallow use of Object.prototypes builtins directly (no-prototype-builtins)
In ECMAScript 5.1, Object.create
was added, which enables the creation of objects with a specified [[Prototype]]
. Object.create(null)
is a common pattern used to create objects that will be used as a Map. This can lead to errors when it is assumed that objects will have properties from Object.prototype
. This rule prevents calling Object.prototype
methods directly from an object.
Rule Details
This rule disallows calling some Object.prototype
methods directly on object instances.
Examples of incorrect code for this rule:
/*eslint no-prototype-builtins: "error"*/
var hasBarProperty = foo.hasOwnProperty("bar");
var isPrototypeOfBar = foo.isPrototypeOf(bar);
var barIsEnumerable = foo.propertyIsEnumerable("bar");
Examples of correct code for this rule:
/*eslint no-prototype-builtins: "error"*/
var hasBarProperty = Object.prototype.hasOwnProperty.call(foo, "bar");
var isPrototypeOfBar = Object.prototype.isPrototypeOf.call(foo, bar);
var barIsEnumerable = {}.propertyIsEnumerable.call(foo, "bar");
When Not To Use It
You may want to turn this rule off if you will never use an object that shadows an Object.prototype
method or which does not inherit from Object.prototype
.
Source: http://eslint.org/docs/rules/