Utilizing Typescript for constructor parameter assignments

Question

Utilizing Typescript for constructor parameter assignments

Within my codebase, there exists an interface:

export interface IFieldValue {
    name: string;
    value: string;
}

This interface is implemented by a class named Person:

class Person implements IFieldValue{
    name: string;
    value: string;
    constructor (name: string, value: string) {
        this.name = name;
        this.value = value;
    }
}

Recently, I came across an interesting post that inspired me to refactor the implementation:

class Person implements IFieldValue{
    constructor(public name: string, public value: string) {
    }
}

My question pertains to the default access modifiers in TypeScript - in the first implementation, the fields are implicitly set as private, while in the refactored version they are automatically set as public. Am I correct in assuming this understanding?

typescript access-modifiers

Answer 1

Answer №1

By default, the information is made public. View TypeScript Documentation

In this particular scenario

class Person implements IFieldValue{
    name: string;
    value: string;
    constructor (name: string, value: string) {
        this.name = name;
        this.value = value;
    }
}

The attributes <Person>.name and <Person>.value are automatically set to public.

as seen in the following code snippet

class Person implements IFieldValue{
    constructor(public name: string, public value: string) {
        this.name = name;
        this.value = value;
    }
}

Note: The incorrect way of approaching this would be by defining this.name and this.value within the constructor.

class Person implements IFieldValue{
    constructor(name: string, value: string) {
        this.name = name;
        this.value = value;
    }
}

To keep these attributes private, a different implementation is required like so

class Person implements IFieldValue{
    private name: string;
    private value: string;
    constructor (name: string, value: string) {
        this.name = name;
        this.value = value;
    }
}

or alternatively

class Person implements IFieldValue{
    constructor (private name: string, private value: string) {}
}

For TypeScript 2.X, where the interface properties are public, changing from private to public and adding export to classes is necessary

export class Person implements IFieldValue{
    constructor (public name: string, public value: string) {}
}

This is considered the most efficient method that eliminates redundancy according to my personal opinion.

Answer 2

By default, the information is made public. View TypeScript Documentation

In this particular scenario

class Person implements IFieldValue{
    name: string;
    value: string;
    constructor (name: string, value: string) {
        this.name = name;
        this.value = value;
    }
}

The attributes <Person>.name and <Person>.value are automatically set to public.

as seen in the following code snippet

class Person implements IFieldValue{
    constructor(public name: string, public value: string) {
        this.name = name;
        this.value = value;
    }
}

Note: The incorrect way of approaching this would be by defining this.name and this.value within the constructor.

class Person implements IFieldValue{
    constructor(name: string, value: string) {
        this.name = name;
        this.value = value;
    }
}

To keep these attributes private, a different implementation is required like so

class Person implements IFieldValue{
    private name: string;
    private value: string;
    constructor (name: string, value: string) {
        this.name = name;
        this.value = value;
    }
}

or alternatively

class Person implements IFieldValue{
    constructor (private name: string, private value: string) {}
}

For TypeScript 2.X, where the interface properties are public, changing from private to public and adding export to classes is necessary

export class Person implements IFieldValue{
    constructor (public name: string, public value: string) {}
}

This is considered the most efficient method that eliminates redundancy according to my personal opinion.

Utilizing Typescript for constructor parameter assignments

Answer №1

Similar questions

Exploring Typescript's Generic Unions

When using Protractor with Typescript, you may encounter the error message "Failed: Cannot read property 'sendKeys' of undefined"

Methods for populating an object with Interface type and returning it

The process of ensuring a component is able to watch for the router even when it is not within the router

A guide on dynamically showcasing/summoning icons in react by utilizing array data

The type of a reference variable in a type definition of another variable

"Changing the name of a symbol that is automatically imported from an internal library in

Encountering browser freezing issues with a Next.JS app when trying to add an input field

How is it that I can assign a string value to my declared number object parameter in Typescript?

Refine a union type by considering the properties already defined in an object

There is a WARNING occurring at line 493 in the file coreui-angular.js located in the node_modules folder. The warning states that the export 'ɵɵdefineInjectable' was not found in the '@angular/core' module

Include a control within a form based on the Observable response

The subsequent code still running even with the implementation of async/await

Testing Angular 11 methods using Jest unit tests within a .then block

Error: unable to locate module that was imported from

Unable to retrieve rxjs resource

I love the idea of the music playing on as I navigate between pages or tabs. Such a cool feature with Next

Issue with Angular 7: "Unspecified name attribute causing control not found"

Could someone provide a detailed explanation of exhaustMap in the context of Angular using rxjs?

Contrary to GraphQLNonNull