Typescript subclass inherited method allow undefined keys in argument

When working with TypeScript, you may come across a situation where you have a subclass that needs to inherit a method from its parent class, but also allow undefined keys in the argument. By default, TypeScript enforces strict typing, which means that any undefined keys in the argument will result in a compilation error. However, there are a few solutions to this problem that can help you achieve the desired behavior.

Solution 1: Use an index signature

One way to allow undefined keys in the argument is to use an index signature. An index signature allows you to define a type for the keys that are not explicitly defined in the argument.


class ParentClass {
  method(arg: { [key: string]: any }) {
    // Method implementation
  }
}

class SubClass extends ParentClass {
  // SubClass inherits the method from ParentClass
}

const instance = new SubClass();
instance.method({ key1: 'value1', key2: 'value2' }); // Valid
instance.method({ key1: 'value1', key2: 'value2', key3: 'value3' }); // Valid
instance.method({}); // Valid

In this solution, we define an index signature in the argument type of the parent class’s method. The index signature allows any string key with any value type. This means that the subclass can pass an object with undefined keys to the inherited method without any compilation errors.

Solution 2: Use a union type with undefined

Another solution is to use a union type with undefined in the argument type. This allows you to explicitly define which keys can be undefined in the argument.


class ParentClass {
  method(arg: { key1?: string, key2?: string }) {
    // Method implementation
  }
}

class SubClass extends ParentClass {
  // SubClass inherits the method from ParentClass
}

const instance = new SubClass();
instance.method({ key1: 'value1', key2: 'value2' }); // Valid
instance.method({ key1: 'value1', key2: 'value2', key3: 'value3' }); // Compilation error: Property 'key3' does not exist on type '{ key1?: string, key2?: string }'
instance.method({}); // Valid

In this solution, we define the keys in the argument type of the parent class’s method as optional by using the “?” symbol. This allows the subclass to pass an object with undefined keys for the optional keys, but it still enforces strict typing for the defined keys.

Conclusion

When you need to allow undefined keys in the argument of a subclass inherited method in TypeScript, you can use either an index signature or a union type with undefined. Both solutions provide flexibility while still maintaining strict typing for the defined keys. Choose the solution that best fits your specific use case.

Remember to always consider the design and requirements of your application when deciding which solution to implement. Happy coding!

Typescript subclass inherited method allow undefined keys in argument