Skip to main content

parameter-properties

Requires or disallows parameter properties in class constructors.

Parameter properties can be confusing to those new to TypeScript as they are less explicit than other ways of declaring and initializing class members.

Attributes

  • Included in configs
    • ✅ Recommended
    • 🔒 Strict
  • Fixable
    • 🔧 Automated Fixer
    • 🛠 Suggestion Fixer
  • 💭 Requires type information

Rule Details

This rule disallows the use of parameter properties in constructors, forcing the user to explicitly declare all properties in the class.

Options

This rule, in its default state, does not require any argument and would completely disallow the use of parameter properties. It may take an options object containing either or both of:

  • "allow": allowing certain kinds of properties to be ignored
  • "prefer": either "class-property" (default) or "parameter-property"

"allow"

If you would like to ignore certain kinds of properties then you may pass an object containing "allow" as an array of any of the following options:

  • allow, an array containing one or more of the allowed modifiers. Valid values are:
    • readonly, allows readonly parameter properties.
    • private, allows private parameter properties.
    • protected, allows protected parameter properties.
    • public, allows public parameter properties.
    • private readonly, allows private readonly parameter properties.
    • protected readonly, allows protected readonly parameter properties.
    • public readonly, allows public readonly parameter properties.

For example, to ignore public properties:

{
"@typescript-eslint/parameter-properties": [
true,
{
"allow": ["public"]
}
]
}

"prefer"

By default, the rule prefers class property ("class-property"). You can switch it to instead preferring parameter property with ("parameter-property").

In "parameter-property" mode, the rule will issue a report when:

  • A class property and constructor parameter have the same name and type
  • The constructor parameter is assigned to the class property at the beginning of the constructor

default

Examples of code for this rule with no options at all:

class Foo {
constructor(readonly name: string) {}
}

class Foo {
constructor(private name: string) {}
}

class Foo {
constructor(protected name: string) {}
}

class Foo {
constructor(public name: string) {}
}

class Foo {
constructor(private readonly name: string) {}
}

class Foo {
constructor(protected readonly name: string) {}
}

class Foo {
constructor(public readonly name: string) {}
}

readonly

Examples of code for the { "allow": ["readonly"] } options:

class Foo {
constructor(private name: string) {}
}

class Foo {
constructor(protected name: string) {}
}

class Foo {
constructor(public name: string) {}
}

class Foo {
constructor(private readonly name: string) {}
}

class Foo {
constructor(protected readonly name: string) {}
}

class Foo {
constructor(public readonly name: string) {}
}

private

Examples of code for the { "allow": ["private"] } options:

class Foo {
constructor(readonly name: string) {}
}

class Foo {
constructor(protected name: string) {}
}

class Foo {
constructor(public name: string) {}
}

class Foo {
constructor(private readonly name: string) {}
}

class Foo {
constructor(protected readonly name: string) {}
}

class Foo {
constructor(public readonly name: string) {}
}

protected

Examples of code for the { "allow": ["protected"] } options:

class Foo {
constructor(readonly name: string) {}
}

class Foo {
constructor(private name: string) {}
}

class Foo {
constructor(public name: string) {}
}

class Foo {
constructor(private readonly name: string) {}
}

class Foo {
constructor(protected readonly name: string) {}
}

class Foo {
constructor(public readonly name: string) {}
}

public

Examples of code for the { "allow": ["public"] } options:

class Foo {
constructor(readonly name: string) {}
}

class Foo {
constructor(private name: string) {}
}

class Foo {
constructor(protected name: string) {}
}

class Foo {
constructor(private readonly name: string) {}
}

class Foo {
constructor(protected readonly name: string) {}
}

class Foo {
constructor(public readonly name: string) {}
}

private readonly

Examples of code for the { "allow": ["private readonly"] } options:

class Foo {
constructor(readonly name: string) {}
}

class Foo {
constructor(private name: string) {}
}

class Foo {
constructor(protected name: string) {}
}

class Foo {
constructor(public name: string) {}
}

class Foo {
constructor(protected readonly name: string) {}
}

class Foo {
constructor(public readonly name: string) {}
}

protected readonly

Examples of code for the { "allow": ["protected readonly"] } options:

class Foo {
constructor(readonly name: string) {}
}

class Foo {
constructor(private name: string) {}
}

class Foo {
constructor(protected name: string) {}
}

class Foo {
constructor(public name: string) {}
}

class Foo {
constructor(private readonly name: string) {}
}

class Foo {
constructor(public readonly name: string) {}
}

public readonly

Examples of code for the { "allow": ["public readonly"] } options:

class Foo {
constructor(readonly name: string) {}
}

class Foo {
constructor(private name: string) {}
}

class Foo {
constructor(protected name: string) {}
}

class Foo {
constructor(public name: string) {}
}

class Foo {
constructor(private readonly name: string) {}
}

class Foo {
constructor(protected readonly name: string) {}
}

"parameter-property"

Examples of code for the { "prefer": "parameter-property" } option:

class Foo {
private name: string;
constructor(name: string) {
this.name = name;
}
}

class Foo {
public readonly name: string;
constructor(name: string) {
this.name = name;
}
}

class Foo {
constructor(name: string) {
this.name = name;
}
name: string;
}

When Not To Use It

If you don't care about the using parameter properties in constructors, then you will not need this rule.