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

资源

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