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

Translating from a higher-level programming language to a lower-level programming language

What is the best way to apply DateRange filtering in a Kendo Ui Grid?

The specified module '...' is identified as a non-module entity and therefore cannot be imported using this specific construct

Importing a file using its absolute path in JavaScript

Upon transitioning from Angular 5 to Angular 6, a noticeable issue arises: The existing document lacks a required doctype

Collaborative service utilization in Angular 2

The ng-bootstrap typeahead is encountering an error: TypeError - Object(...) is not functioning correctly

Show the user's chosen name in place of their actual identity during a chat

Determining the type of an overloaded method within a generic function

The error encountered is: "Unable to modify the 'x' property as it is readonly for the '[object Array]' object."

Error encountered in Typescript while attempting to $set a subdocument key value in MongoDB

Using `querySelector` in TypeScript with Vue 3

What is the best way to mock imports in NestJS testing?

What are some effective ways to create a flexible framework in Typescript for Node.js applications utilizing the native MongoDB driver?

I am having trouble locating my source code within the Typescript module

NodeJS can be used to convert JSON data into an XLSX file format and allow for

Utilizing a class structure to organize express.Router?

Error Message: The Reference.update operation in Angular Firebase failed due to the presence of undefined value in the 'users.UID.email' property

Can you explain the distinction, if one exists, between a field value and a property within the context of TypeScript and Angular?

Error in Visual Studio 2019 - TypeScript version discrepancy