Is there a better shorthand for Typescript class/interface definitions?

user_10426087 0
Viewed 148

I'm defining a typescript class with constructor parameters defined by an interface, and it restricts the properties to only those that are defined.

The following code snippet works as intended, however, is there a way to reduce the code so that it isn't so repetitive? Each property is mentioned 4 times, there must be a better way.

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);

EDIT: I also need to restrict the properties at run-time from objects with additional unknown properties.

typescript shorthand class
4 Answers

How's this?

interface MyInterface {
    property1: string;
    property2: boolean;
    property3: number;
}

class MyClass implements MyInterface {
    property1: string;
    property2: boolean;
    property3: number;

    constructor(parameters: MyInterface) {
        Object.assign(this, parameters);
    }
}
user_132103600

Yes, it is possible, but then you need to story class argument in 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

Please see the public keyword I have added in constructor

enter image description here

If you want to validate your object in runtime, you should either use user-defined-type-guards or io-ts

TypeScript has static type system

user_84952540

I believe this would be the most concise way, but not necessarily the best. It depends on your use case—specifically whether or not the parameters in the constructor will always match the declared properties of your class. If not, then you would want to stick with using an interface (and using an interface might be cleaner anyway).

class MyClass {
    property1!: string
    property2!: boolean
    property3!: number

    constructor(parameters: typeof MyClass.prototype) {
        Object.assign(this, parameters)
    }
}
user_5601140 
interface MyInterface {
  property1: string;
  property2: boolean;
  property3: number;
}

class MyClass implements MyInterface {
  constructor(
    public property1: string,
    public property2: boolean,
    public property3: number
  ) { }
}

const example = new MyClass("Property 1", true, 3, "Shouldn't exist");
console.log(example);

By putting public in the constructor arguments, I don't need to declare them outside of the constructor. MyClass implements MyInterface so that I know I have declared all properties I need in MyClass.

Maybe this doesn't really apply to your needs since you'll have to manually assign each property in the constructor, but it might give you something to think about.

user_14868480
Related