]>
Commit | Line | Data |
---|---|---|
eb39fafa DC |
1 | # require function names to match the name of the variable or property to which they are assigned (func-name-matching) |
2 | ||
3 | ## Rule Details | |
4 | ||
5 | This rule requires function names to match the name of the variable or property to which they are assigned. The rule will ignore property assignments where the property name is a literal that is not a valid identifier in the ECMAScript version specified in your configuration (default ES5). | |
6 | ||
7 | Examples of **incorrect** code for this rule: | |
8 | ||
9 | ```js | |
10 | /*eslint func-name-matching: "error"*/ | |
11 | ||
12 | var foo = function bar() {}; | |
13 | foo = function bar() {}; | |
14 | obj.foo = function bar() {}; | |
15 | obj['foo'] = function bar() {}; | |
16 | var obj = {foo: function bar() {}}; | |
17 | ({['foo']: function bar() {}}); | |
609c276f TL |
18 | |
19 | class C { | |
20 | foo = function bar() {}; | |
21 | } | |
eb39fafa DC |
22 | ``` |
23 | ||
24 | ```js | |
25 | /*eslint func-name-matching: ["error", "never"] */ | |
26 | ||
27 | var foo = function foo() {}; | |
28 | foo = function foo() {}; | |
29 | obj.foo = function foo() {}; | |
30 | obj['foo'] = function foo() {}; | |
31 | var obj = {foo: function foo() {}}; | |
32 | ({['foo']: function foo() {}}); | |
609c276f TL |
33 | |
34 | class C { | |
35 | foo = function foo() {}; | |
36 | } | |
eb39fafa DC |
37 | ``` |
38 | ||
39 | Examples of **correct** code for this rule: | |
40 | ||
41 | ```js | |
42 | /*eslint func-name-matching: "error"*/ | |
43 | /*eslint func-name-matching: ["error", "always"]*/ // these are equivalent | |
44 | /*eslint-env es6*/ | |
45 | ||
46 | var foo = function foo() {}; | |
47 | var foo = function() {}; | |
48 | var foo = () => {}; | |
49 | foo = function foo() {}; | |
50 | ||
51 | obj.foo = function foo() {}; | |
52 | obj['foo'] = function foo() {}; | |
53 | obj['foo//bar'] = function foo() {}; | |
54 | obj[foo] = function bar() {}; | |
55 | ||
56 | var obj = {foo: function foo() {}}; | |
57 | var obj = {[foo]: function bar() {}}; | |
58 | var obj = {'foo//bar': function foo() {}}; | |
59 | var obj = {foo: function() {}}; | |
60 | ||
61 | obj['x' + 2] = function bar(){}; | |
62 | var [ bar ] = [ function bar(){} ]; | |
63 | ({[foo]: function bar() {}}) | |
64 | ||
609c276f TL |
65 | class C { |
66 | foo = function foo() {}; | |
67 | baz = function() {}; | |
68 | } | |
69 | ||
70 | // private names are ignored | |
71 | class D { | |
72 | #foo = function foo() {}; | |
73 | #bar = function foo() {}; | |
74 | baz() { | |
75 | this.#foo = function foo() {}; | |
76 | this.#foo = function bar() {}; | |
77 | } | |
78 | } | |
79 | ||
eb39fafa DC |
80 | module.exports = function foo(name) {}; |
81 | module['exports'] = function foo(name) {}; | |
82 | ``` | |
83 | ||
84 | ```js | |
85 | /*eslint func-name-matching: ["error", "never"] */ | |
86 | /*eslint-env es6*/ | |
87 | ||
88 | var foo = function bar() {}; | |
89 | var foo = function() {}; | |
90 | var foo = () => {}; | |
91 | foo = function bar() {}; | |
92 | ||
93 | obj.foo = function bar() {}; | |
94 | obj['foo'] = function bar() {}; | |
95 | obj['foo//bar'] = function foo() {}; | |
96 | obj[foo] = function foo() {}; | |
97 | ||
98 | var obj = {foo: function bar() {}}; | |
99 | var obj = {[foo]: function foo() {}}; | |
100 | var obj = {'foo//bar': function foo() {}}; | |
101 | var obj = {foo: function() {}}; | |
102 | ||
103 | obj['x' + 2] = function bar(){}; | |
104 | var [ bar ] = [ function bar(){} ]; | |
105 | ({[foo]: function bar() {}}) | |
106 | ||
609c276f TL |
107 | class C { |
108 | foo = function bar() {}; | |
109 | baz = function() {}; | |
110 | } | |
111 | ||
112 | // private names are ignored | |
113 | class D { | |
114 | #foo = function foo() {}; | |
115 | #bar = function foo() {}; | |
116 | baz() { | |
117 | this.#foo = function foo() {}; | |
118 | this.#foo = function bar() {}; | |
119 | } | |
120 | } | |
121 | ||
eb39fafa DC |
122 | module.exports = function foo(name) {}; |
123 | module['exports'] = function foo(name) {}; | |
124 | ``` | |
125 | ||
126 | ## Options | |
127 | ||
128 | This rule takes an optional string of "always" or "never" (when omitted, it defaults to "always"), and an optional options object with two properties `considerPropertyDescriptor` and `includeCommonJSModuleExports`. | |
129 | ||
130 | ### considerPropertyDescriptor | |
131 | ||
132 | A boolean value that defaults to `false`. If `considerPropertyDescriptor` is set to true, the check will take into account the use of `Object.create`, `Object.defineProperty`, `Object.defineProperties`, and `Reflect.defineProperty`. | |
133 | ||
134 | Examples of **correct** code for the `{ considerPropertyDescriptor: true }` option: | |
135 | ||
136 | ```js | |
137 | /*eslint func-name-matching: ["error", { "considerPropertyDescriptor": true }]*/ | |
138 | /*eslint func-name-matching: ["error", "always", { "considerPropertyDescriptor": true }]*/ // these are equivalent | |
139 | var obj = {}; | |
140 | Object.create(obj, {foo:{value: function foo() {}}}); | |
141 | Object.defineProperty(obj, 'bar', {value: function bar() {}}); | |
142 | Object.defineProperties(obj, {baz:{value: function baz() {} }}); | |
143 | Reflect.defineProperty(obj, 'foo', {value: function foo() {}}); | |
144 | ``` | |
145 | ||
146 | Examples of **incorrect** code for the `{ considerPropertyDescriptor: true }` option: | |
147 | ||
148 | ```js | |
149 | /*eslint func-name-matching: ["error", { "considerPropertyDescriptor": true }]*/ | |
150 | /*eslint func-name-matching: ["error", "always", { "considerPropertyDescriptor": true }]*/ // these are equivalent | |
151 | var obj = {}; | |
152 | Object.create(obj, {foo:{value: function bar() {}}}); | |
153 | Object.defineProperty(obj, 'bar', {value: function baz() {}}); | |
154 | Object.defineProperties(obj, {baz:{value: function foo() {} }}); | |
155 | Reflect.defineProperty(obj, 'foo', {value: function value() {}}); | |
156 | ``` | |
157 | ||
158 | ### includeCommonJSModuleExports | |
159 | ||
160 | A boolean value that defaults to `false`. If `includeCommonJSModuleExports` is set to true, `module.exports` and `module["exports"]` will be checked by this rule. | |
161 | ||
162 | Examples of **incorrect** code for the `{ includeCommonJSModuleExports: true }` option: | |
163 | ||
164 | ```js | |
165 | /*eslint func-name-matching: ["error", { "includeCommonJSModuleExports": true }]*/ | |
166 | /*eslint func-name-matching: ["error", "always", { "includeCommonJSModuleExports": true }]*/ // these are equivalent | |
167 | ||
168 | module.exports = function foo(name) {}; | |
169 | module['exports'] = function foo(name) {}; | |
170 | ``` | |
171 | ||
172 | ## When Not To Use It | |
173 | ||
174 | Do not use this rule if you want to allow named functions to have different names from the variable or property to which they are assigned. | |
175 | ||
176 | ## Compatibility | |
177 | ||
178 | * **JSCS**: [requireMatchingFunctionName](https://jscs-dev.github.io/rule/requireMatchingFunctionName) |