src/content/docs/linter/rules/use-consistent-member-accessibility.mdx
import { Tabs, TabItem } from '@astrojs/starlight/components';
<Tabs> <TabItem label="TypeScript and TSX" icon="seti:typescript"> ## Summary - Rule available since: `v1.9.0` - Diagnostic Category: [`lint/style/useConsistentMemberAccessibility`](/reference/diagnostics#diagnostic-category) - This rule isn't recommended, so you need to enable it. - This rule doesn't have a fix. - The default severity of this rule is [**information**](/reference/diagnostics#information). - Sources: - Same as [`@typescript-eslint/explicit-member-accessibility`](https://typescript-eslint.io/rules/explicit-member-accessibility){
"linter": {
"rules": {
"style": {
"useConsistentMemberAccessibility": "error"
}
}
}
}
Require consistent accessibility modifiers on class properties and methods.
TypeScript allows placing explicit public, protected, and private accessibility modifiers in front of class members.
The modifiers exist solely in the type system and just serve to describe who is allowed to access those members.
Leaving off accessibility modifiers makes for less code to read and write. Members are public by default.
However, adding in consistent accessibility modifiers can be helpful in codebases with many classes for enforcing proper privacy of members. Some developers also find it preferable for code readability to keep member publicity explicit.
"accessibility": "noPublic" (default value)Use the following configuration to disallow all explicit public modifiers:
{
"linter": {
"rules": {
"style": {
"useConsistentMemberAccessibility": {
"options": {
"accessibility": "noPublic"
}
}
}
}
}
}
The following patterns are considered incorrect code with noPublic:
class Animal {
public constructor(breed, name) {
// ...
}
}
class Animal {
constructor(
public breed,
name,
) {
// ...
}
}
class Animal {
public animalName: string;
}
class Pet {
public get name(): string {
return this.animalName;
}
}
class Pet {
public set name(value: string) {
this.animalName = value;
}
}
class Dog {
public walk() {
// ...
}
}
"accessibility": "explicit"Use the following configuration to enforce the presence of explicit modifiers wherever possible:
{
"linter": {
"rules": {
"style": {
"useConsistentMemberAccessibility": {
"options": {
"accessibility": "explicit"
}
}
}
}
}
}
The following patterns are considered incorrect code with accessibility set to explicit:
class Animal {
constructor( // Invalid: Missing accessibility modifier
public breed,
name,
) {
this.animalName = name;
}
private animalName: string; // OK: Modifier must be present
public get name(): string { // OK: Modifier must be present
return this.animalName;
}
public set name(value: string) { // OK: Modifier must be present
this.animalName = value;
}
protected walk() { // OK: Modifier must be present
// ...
}
}
"accessibility": "none"Use the following configuration to disallow all explicit visibility modifiers:
{
"linter": {
"rules": {
"style": {
"useConsistentMemberAccessibility": {
"options": {
"accessibility": "none"
}
}
}
}
}
}
The following patterns are considered incorrect code with accessibility set to none:
class Animal {
protected constructor(breed, name) {
// ...
}
}
class Animal {
constructor(
protected breed,
name,
) {
// ...
}
}
class Animal {
private animalName: string;
}
class Animal {
protected get name(): string {
return this.animalName;
}
}
class Pet {
private set name(value: string) {
this.animalName = value;
}
}
class Dog {
public walk() {
// ...
}
}
The following patterns are considered correct code with the default options noPublic:
{
"linter": {
"rules": {
"style": {
"useConsistentMemberAccessibility": {
"options": {
"accessibility": "noPublic"
}
}
}
}
}
}
class Animal {
constructor(
private breed,
name,
) {
this.animalName = name;
}
private animalName: string; // Property
get name(): string {
// get accessor
return this.animalName;
}
set name(value: string) {
// set accessor
this.animalName = value;
}
protected walk() {
// method
}
}
The following patterns are considered correct code with the accessibility set to explicit:
{
"linter": {
"rules": {
"style": {
"useConsistentMemberAccessibility": {
"options": {
"accessibility": "explicit"
}
}
}
}
}
}
class Animal {
public constructor(
public breed,
name,
) {
// Parameter property and constructor
this.animalName = name;
}
private animalName: string; // Property
public get name(): string {
// get accessor
return this.animalName;
}
public set name(value: string) {
// set accessor
this.animalName = value;
}
protected walk() {
// method
}
}
The following patterns are considered correct code with the accessibility set to none:
{
"linter": {
"rules": {
"style": {
"useConsistentMemberAccessibility": {
"options": {
"accessibility": "none"
}
}
}
}
}
}
class Animal {
constructor(
breed,
name,
) {
// Parameter property and constructor
this.name = name;
}
animalName: string; // Property
get name(): string {
// get accessor
return this.animalName;
}
set name(value: string) {
// set accessor
this.animalName = value;
}
walk() {
// method
}
}
The rule supports the following options:
{
"linter": {
"rules": {
"style": {
"useConsistentMemberAccessibility": {
"options": {
"accessibility": "explicit"
}
}
}
}
}
}
accessibilityThis option determines the required accessibility modifiers on class properties and methods. It can be set to one of the following values:
noPublic - forbid the use of the public modifier.explicit - requires an accessibility modifier for every member where it is permitted.none - forbid all accessibility modifiers (public, protected, private).Default: noPublic