Do you know of a more efficient way to write Typescript class and interface definitions?

Question

Do you know of a more efficient way to write Typescript class and interface definitions?

In my TypeScript project, I'm creating a class with constructor parameters defined by an interface to limit the properties to only those that are specified.

Although the current code snippet achieves the desired functionality, I am looking for a way to streamline it and eliminate repetition. Each property is mentioned 4 times in the code, which seems redundant. Is there a more efficient approach?

interface MyInterface {
  property1: string;
  property2: boolean;
  property3: number;
}
class MyClass {
  property1: string;
  property2: boolean;
  property3: number;
  constructor(parameters: MyInterface) {
    this.property1 = parameters.property1;
    this.property2 = parameters.property2;
    this.property3 = parameters.property3;
  }
}

const example = new MyClass({property1: "Property 1", property2: true, property3: 3, extraProperty: "Shouldn't exist"});
console.log(example);

UPDATE: Additionally, I need to ensure that the properties are restricted at run-time to prevent objects with unknown additional properties.

typescript class shorthand

Answer 1

Answer №1

What do you think about this code?

interface AnotherInterface {
    item1: string;
    item2: boolean;
    item3: number;
}

class AnotherClass implements AnotherInterface {
    item1: string;
    item2: boolean;
    item3: number;

    constructor(values: AnotherInterface) {
        Object.assign(this, values);
    }
}

Answer 2

What do you think about this code?

interface AnotherInterface {
    item1: string;
    item2: boolean;
    item3: number;
}

class AnotherClass implements AnotherInterface {
    item1: string;
    item2: boolean;
    item3: number;

    constructor(values: AnotherInterface) {
        Object.assign(this, values);
    }
}

Answer 3

Answer №2

In my opinion, this approach seems to offer a balance between brevity and efficiency. However, its effectiveness may vary depending on the specific requirements of your implementation—particularly whether the constructor's parameters will consistently align with the class properties. If there is potential for mismatch, utilizing an interface could provide a more organized solution.

class CustomClass {
    prop1!: string
    prop2!: boolean
    prop3!: number

    constructor(params: typeof CustomClass.prototype) {
        Object.assign(this, params)
    }
}

Answer 4

In my opinion, this approach seems to offer a balance between brevity and efficiency. However, its effectiveness may vary depending on the specific requirements of your implementation—particularly whether the constructor's parameters will consistently align with the class properties. If there is potential for mismatch, utilizing an interface could provide a more organized solution.

class CustomClass {
    prop1!: string
    prop2!: boolean
    prop3!: number

    constructor(params: typeof CustomClass.prototype) {
        Object.assign(this, params)
    }
}

Answer 5

Answer №3

interface YourInterface {
  item1: string;
  item2: boolean;
  item3: number;
}

class YourClass implements YourInterface {
  constructor(
    public item1: string,
    public item2: boolean,
    public item3: number
  ) { }
}

const example = new YourClass("Item 1", true, 5, "Should not be included");
console.log(example);

By using public in the constructor parameters, I can avoid declaring them outside of the constructor function. The YourClass class adheres to the YourInterface interface to ensure all required properties are present.

This approach may not be suitable for your specific requirements as each property needs to be assigned manually in the constructor. Nonetheless, it could offer some valuable insights.

Answer 6

interface YourInterface {
  item1: string;
  item2: boolean;
  item3: number;
}

class YourClass implements YourInterface {
  constructor(
    public item1: string,
    public item2: boolean,
    public item3: number
  ) { }
}

const example = new YourClass("Item 1", true, 5, "Should not be included");
console.log(example);

By using public in the constructor parameters, I can avoid declaring them outside of the constructor function. The YourClass class adheres to the YourInterface interface to ensure all required properties are present.

This approach may not be suitable for your specific requirements as each property needs to be assigned manually in the constructor. Nonetheless, it could offer some valuable insights.

Answer 7

Answer №4

Absolutely, it is achievable but you must include the story class argument in the parameters property:

interface MyInterface {
  property1: string;
  property2: boolean;
  property3: number;
}
class MyClass {
  constructor(public parameters: MyInterface) {  }
}

const example = new MyClass({ property1: "Property 1", property2: true, property3: 3, extraProperty: "Shouldn't exist" });
console.log(example);

example.parameters.property1 // ok

Playground

Kindly note the usage of the public keyword I have included within the constructor

https://i.sstatic.net/ovNUp.png

If you wish to validate your object at runtime, you should consider implementing either user-defined type guards or io-ts

TypeScript boasts a static type system

Answer 8

Absolutely, it is achievable but you must include the story class argument in the parameters property:

interface MyInterface {
  property1: string;
  property2: boolean;
  property3: number;
}
class MyClass {
  constructor(public parameters: MyInterface) {  }
}

const example = new MyClass({ property1: "Property 1", property2: true, property3: 3, extraProperty: "Shouldn't exist" });
console.log(example);

example.parameters.property1 // ok

Playground

Kindly note the usage of the public keyword I have included within the constructor

https://i.sstatic.net/ovNUp.png

If you wish to validate your object at runtime, you should consider implementing either user-defined type guards or io-ts

TypeScript boasts a static type system

Do you know of a more efficient way to write Typescript class and interface definitions?

Answer №1

Answer №2

Answer №3

Answer №4

Similar questions

Tips for integrating TypeScript files into Next.js HTML files

Identify when the Vue page changes and execute the appropriate function

Eliminate Elements from Array - Angular Four

Mocking a promise rejection in Jest to ensure that the calling function properly handles rejections

Exploring the powerful combination of React, Typescript, and the dynamic import Higher Order

Encountering an issue with React Redux and Typescript involving the AnyAction error while working on implementing

The successful completion of an Angular2 HTTP request relies on the data obtained from a previous response

Encountering an error in TypeScript: Attempting to define type files for a third-party library triggers the TS2709 error when attempting to use the 'Optional' namespace as a type

Initiate asynchronous ngOnInit

The parameter 'Barable' cannot be assigned to the parameter 'T' as they are not compatible

Is there a way for me to determine if there are elements in one object array that exist in another object

Changing the name of an Angular2 import module

Is it feasible to set an empty object as the initial default value in the state of a React component?

Enhancing editor.selections in Visual Studio Code Extension

It appears that Yarn is having trouble properly retrieving all the necessary files for a package

Tips for testing SSM's GetParameter with aws-sdk-client-mock in typescript

The visibility of the button is dependent on refreshing the page with the F5

Tips for successfully importing $lib in SvelteKit without encountering any TypeScript errors

Send a string to directive via HTML

Is it possible to identify and differentiate objects based on their interface types in JavaScript/TypeScript?