accessor-pairs

在对象和类中强制执行 getter 和 setter 对

在 JavaScript 中，创建一个仅包含属性的 setter 而不定义相应的 getter 是一个常见的错误。没有 getter，您无法读取属性，因此它最终不会被使用。

以下是一些示例

// Bad
var o = {
    set a(value) {
        this.val = value;
    }
};


// Good
var o = {
    set a(value) {
        this.val = value;
    },
    get a() {
        return this.val;
    }
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

如果定义了 setter 但没有 getter，则此规则会发出警告。使用选项 getWithoutSet，如果存在 getter 但没有 setter，它也会发出警告。

规则详细信息

此规则强制执行一种样式，它要求为每个定义了 setter 的属性都有一个 getter。

通过激活选项 getWithoutSet，它强制为每个定义了 getter 的属性都存在 setter。

此规则始终检查对象字面量和属性描述符。默认情况下，它还会检查类声明和类表达式。

选项

• setWithoutGet 设置为 true 将对没有 getter 的 setter 发出警告（默认值为 true）。
• getWithoutSet 设置为 true 将对没有 setter 的 getter 发出警告（默认值为 false）。
• enforceForClassMembers 设置为 true 会将此规则额外应用于类 getter/setter（默认值为 true）。如果您希望此规则忽略类声明和类表达式，请将 enforceForClassMembers 设置为 false。

setWithoutGet

针对默认 { "setWithoutGet": true } 选项的 **错误** 代码示例

/*eslint accessor-pairs: "error"*/

var o = {
    set a(value) {
        this.val = value;
    }
};


var o = {d: 1};
Object.defineProperty(o, 'c', {
    set: function(value) {
        this.val = value;
    }
});
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

针对默认 { "setWithoutGet": true } 选项的 **正确** 代码示例

/*eslint accessor-pairs: "error"*/

var o = {
    set a(value) {
        this.val = value;
    },
    get a() {
        return this.val;
    }
};

var o = {d: 1};
Object.defineProperty(o, 'c', {
    set: function(value) {
        this.val = value;
    },
    get: function() {
        return this.val;
    }
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

getWithoutSet

针对 { "getWithoutSet": true } 选项的 **错误** 代码示例

/*eslint accessor-pairs: ["error", { "getWithoutSet": true }]*/

var o = {
    set a(value) {
        this.val = value;
    }
};

var o = {
    get a() {
        return this.val;
    }
};

var o = {d: 1};
Object.defineProperty(o, 'c', {
    set: function(value) {
        this.val = value;
    }
});

var o = {d: 1};
Object.defineProperty(o, 'c', {
    get: function() {
        return this.val;
    }
});
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

针对 { "getWithoutSet": true } 选项的 **正确** 代码示例

/*eslint accessor-pairs: ["error", { "getWithoutSet": true }]*/
var o = {
    set a(value) {
        this.val = value;
    },
    get a() {
        return this.val;
    }
};

var o = {d: 1};
Object.defineProperty(o, 'c', {
    set: function(value) {
        this.val = value;
    },
    get: function() {
        return this.val;
    }
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

enforceForClassMembers

当 enforceForClassMembers 设置为 true（默认值）时

• "getWithoutSet": true 也会对类中没有 setter 的 getter 发出警告。
• "setWithoutGet": true 也会对类中没有 getter 的 setter 发出警告。

针对 { "getWithoutSet": true, "enforceForClassMembers": true } 的 **错误** 代码示例

/*eslint accessor-pairs: ["error", { "getWithoutSet": true, "enforceForClassMembers": true }]*/

class Foo {
    get a() {
        return this.val;
    }
}

class Bar {
    static get a() {
        return this.val;
    }
}

const Baz = class {
    get a() {
        return this.val;
    }
    static set a(value) {
        this.val = value;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

针对 { "setWithoutGet": true, "enforceForClassMembers": true } 的 **错误** 代码示例

/*eslint accessor-pairs: ["error", { "setWithoutGet": true, "enforceForClassMembers": true }]*/

class Foo {
    set a(value) {
        this.val = value;
    }
}

const Bar = class {
    static set a(value) {
        this.val = value;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

当 enforceForClassMembers 设置为 false 时，此规则会忽略类。

针对 { "getWithoutSet": true, "setWithoutGet": true, "enforceForClassMembers": false } 的 **正确** 代码示例

/*eslint accessor-pairs: ["error", {
    "getWithoutSet": true, "setWithoutGet": true, "enforceForClassMembers": false
}]*/

class Foo {
    get a() {
        return this.val;
    }
}

class Bar {
    static set a(value) {
        this.val = value;
    }
}

const Baz = class {
    static get a() {
        return this.val;
    }
}

const Quux = class {
    set a(value) {
        this.val = value;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

已知局限性

由于静态分析的限制，此规则不会考虑可能的副作用，在某些情况下可能不会为具有计算键的 getter/setter 报告缺少的对，例如以下示例

/*eslint accessor-pairs: "error"*/

var a = 1;

// no warnings
var o = {
    get [a++]() {
        return this.val;
    },
    set [a++](value) {
        this.val = value;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13

此外，此规则不允许对象字面量和类定义中出现重复的键，并且在某些情况下，如果存在重复的键，可能不会为 getter/setter 报告缺少的对，例如以下示例

/*eslint accessor-pairs: "error"*/

// no warnings
var o = {
    get a() {
        return this.val;
    },
    a: 1,
    set a(value) {
        this.val = value;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12

上面的代码创建了一个对象，该对象仅包含属性 "a" 的 setter。

如果您还想在对象字面量中禁止重复的键，请参阅 no-dupe-keys。

如果您还想在类定义中禁止重复的名称，请参阅 no-dupe-class-members。

何时不使用它

如果您不关心对象上 setter 和 getter 的同时存在，可以关闭此规则。

相关规则

• no-dupe-keys
• no-dupe-class-members

版本

此规则在 ESLint v0.22.0 中引入。

进一步阅读

setter - JavaScript | MDN
developer.mozilla.org

getter - JavaScript | MDN
developer.mozilla.org

使用对象 - JavaScript | MDN
developer.mozilla.org

资源

• 规则源代码
• 测试源代码