# grouped-accessor-pairs

在对象字面量和类中需要分组访问器对

相同属性的 getter 和 setter 不一定必须彼此相邻定义。

例如，以下语句将创建相同的对象：

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

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

虽然允许在对象或类定义中的任何位置为 getter 或 setter 定义对，但将访问器函数分组为同一属性被认为是最佳实践。

换句话说，如果一个属性有一个 getter 和一个 setter，那么 setter 应该在 getter 之后定义，反之亦然。

# 规则详情

此规则要求对象字面量、类声明和类表达式中相同属性的访问器函数的分组定义。

或者，此规则还可以强制执行一致的顺序（getBeforeSet 或 setBeforeGet）。

此规则不强制对 getter 或 setter 的存在。如果您还想强制执行 getter/setter 对，请参阅 accessor-pairs。

此规则的错误代码示例：

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

var foo = {
    get a() {
        return this.val;
    },
    b: 1,
    set a(value) {
        this.val = value;
    }
};

var bar = {
    set b(value) {
        this.val = value;
    },
    a: 1,
    get b() {
        return this.val;
    }
}

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

const Bar = class {
    static get a() {
        return this.val;
    }
    b(){}
    static set a(value) {
        this.val = value;
    }
}

此规则的正确代码示例：

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

var foo = {
    get a() {
        return this.val;
    },
    set a(value) {
        this.val = value;
    },
    b: 1
};

var bar = {
    set b(value) {
        this.val = value;
    },
    get b() {
        return this.val;
    },
    a: 1
}

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

const Bar = class {
    static get a() {
        return this.val;
    }
    static set a(value) {
        this.val = value;
    }
    b(){}
}

# 选项

此规则有一个字符串选项：

"anyOrder"（默认）不强制执行顺序。
"getBeforeSet" 如果属性同时具有 getter 和 setter，则要求在 setter 之前定义 getter。
"setBeforeGet" 如果属性同时具有 getter 和 setter，则要求在 getter 之前定义 setter。

# getBeforeSet

此规则使用 "getBeforeSet" 选项的错误代码示例：

/*eslint grouped-accessor-pairs: ["error", "getBeforeSet"]*/

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

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

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

此规则使用 "getBeforeSet" 选项的正确代码示例：

/*eslint grouped-accessor-pairs: ["error", "getBeforeSet"]*/

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

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

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

# setBeforeGet

此规则使用 "setBeforeGet" 选项的错误代码示例：

/*eslint grouped-accessor-pairs: ["error", "setBeforeGet"]*/

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

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

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

此规则使用 "setBeforeGet" 选项的正确代码示例：

/*eslint grouped-accessor-pairs: ["error", "setBeforeGet"]*/

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

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

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

# 已知限制

由于静态分析的限制，此规则不考虑可能的副作用，并且在某些情况下可能需要或未要求对具有计算键的 getter/setter 进行分组或排序，如下例所示：

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

var a = 1;

// false warning (false positive)
var foo = {
    get [a++]() {
        return this.val;
    },
    b: 1,
    set [a++](value) {
        this.val = value;
    }
};

// missed warning (false negative)
var bar = {
    get [++a]() {
        return this.val;
    },
    b: 1,
    set [a](value) {
        this.val = value;
    }
};

此外，对于具有重复 getter 或 setter 的属性，此规则不会报告任何警告。

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

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

← func-style guard-for-in →