What is the best way to access all the attributes (excluding methods) of an object in a class instance?

Question

What is the best way to access all the attributes (excluding methods) of an object in a class instance?

My goal is to generate a new object type that inherits all the properties from an existing class instance. In other words, I am looking for a way to transform a class instance into a plain object.

For example, consider the following scenario:

class Foobar {
    foo: number = 0;

    bar(): void {} 
}

type ClassProperties<C extends new(...args: readonly unknown[]) => unknown> =
    C extends new(...args: readonly unknown[]) => infer R 
        ? { [K in keyof R]: R[K] } 
        : never
;

const foobar = new Foobar();
const data: ClassProperties<typeof Foobar> = { ...foobar };

However, when I try to implement this, TypeScript throws an error saying

Property 'bar' is missing in type '{ foo: number; }' but required in type '{ foo: number; bar: () => void; }'

.

I find this issue puzzling since it appears to be a straightforward task. Is there a reliable solution to this problem?

Any insights would be highly appreciated.

typescript

Answer 1

Answer №1

To achieve the desired result, you must iterate over each property individually and apply different conditions to each one. However, the current mapped type you are using treats all properties identically:

{ [K in keyof R]: R[K] }

A more effective approach is to utilize key renaming within a mapped type to conditionally map function properties to never, effectively removing them from the resulting type:

type Newable = { new(...args: readonly unknown[]): unknown }
type AnyFn = (...args: unknown[]) => unknown

type ClassProperties<C extends Newable> = {
    [
        K in keyof InstanceType<C>
            as InstanceType<C>[K] extends AnyFn
                ? never
                : K
    ]: InstanceType<C>[K]
}

In this updated version, I have defined separate types for Newable and AnyFn for clarity. Additionally, I replaced your use of infer with TypeScript's built-in InstanceType.

The mapped type now iterates over each key of the class instances. Using as, it applies a conditional check to each property name. If the property is a function, it is mapped to never; otherwise, the key remains unchanged.

The value of each mapped property remains the same as it was on the instance, ensuring the value type is preserved.

This approach accurately produces the expected outcome:

class Foobar {
    foo: number = 0;
    bar(): void {} 
}

type Test = ClassProperties<typeof Foobar>
// { foo: number }

const foobar = new Foobar();
const data: ClassProperties<typeof Foobar> = { ...foobar }; // works correctly

See playground

Alternatively, you can simplify the process by directly passing in the instance type to your type definition:

type ClassProperties<C> = {
    [K in keyof C as C[K] extends AnyFn ? never : K]: C[K]
}

class Foobar {
    foo: number = 0;
    bar(): number {return 123} 
}

type Test = ClassProperties<Foobar>
// { foo: number }

const foobar = new Foobar();
const data: ClassProperties<Foobar> = { ...foobar }; // works fine

See playground

Answer 2

To achieve the desired result, you must iterate over each property individually and apply different conditions to each one. However, the current mapped type you are using treats all properties identically:

{ [K in keyof R]: R[K] }

A more effective approach is to utilize key renaming within a mapped type to conditionally map function properties to never, effectively removing them from the resulting type:

type Newable = { new(...args: readonly unknown[]): unknown }
type AnyFn = (...args: unknown[]) => unknown

type ClassProperties<C extends Newable> = {
    [
        K in keyof InstanceType<C>
            as InstanceType<C>[K] extends AnyFn
                ? never
                : K
    ]: InstanceType<C>[K]
}

In this updated version, I have defined separate types for Newable and AnyFn for clarity. Additionally, I replaced your use of infer with TypeScript's built-in InstanceType.

The mapped type now iterates over each key of the class instances. Using as, it applies a conditional check to each property name. If the property is a function, it is mapped to never; otherwise, the key remains unchanged.

The value of each mapped property remains the same as it was on the instance, ensuring the value type is preserved.

This approach accurately produces the expected outcome:

class Foobar {
    foo: number = 0;
    bar(): void {} 
}

type Test = ClassProperties<typeof Foobar>
// { foo: number }

const foobar = new Foobar();
const data: ClassProperties<typeof Foobar> = { ...foobar }; // works correctly

See playground

Alternatively, you can simplify the process by directly passing in the instance type to your type definition:

type ClassProperties<C> = {
    [K in keyof C as C[K] extends AnyFn ? never : K]: C[K]
}

class Foobar {
    foo: number = 0;
    bar(): number {return 123} 
}

type Test = ClassProperties<Foobar>
// { foo: number }

const foobar = new Foobar();
const data: ClassProperties<Foobar> = { ...foobar }; // works fine

See playground

Answer 3

Answer №2

Looking to enhance the previous type mentioned in Alex Wayne's response by utilizing the global type Function. This choice is preferred as it seamlessly integrates with class methods and offers a more concise solution:

type ClassProperties<C> = {
    [K in keyof C as C[K] extends Function ? never : K]: C[K]
}

Answer 4

Looking to enhance the previous type mentioned in Alex Wayne's response by utilizing the global type Function. This choice is preferred as it seamlessly integrates with class methods and offers a more concise solution:

type ClassProperties<C> = {
    [K in keyof C as C[K] extends Function ? never : K]: C[K]
}

What is the best way to access all the attributes (excluding methods) of an object in a class instance?

Answer №1

Answer №2

Similar questions

Looping through children components in a LitElement template

Issue encountered during mozjpeg installation - unable to locate mozjpeg's cjpeg in the vendor directory due to

Conceal multiple parameters within routing for added security

Tips for accessing other environment variables within the environment.ts file in an Angular project

Template URI parameters are being used in a router call

Issue: Module '@nrwl/workspace/src/utilities/perf-logging' not found

How can I utilize npm with the original source code instead of minified or bundled code?

Can we establish communication between the backend and frontend in React JS by utilizing localstorage?

What is the best way to showcase the outcome of a function on the user interface in Angular 2?

Mapping a response object to a Type interface with multiple Type Interfaces in Angular 7: A step-by-step guide

What is causing my function to execute twice in all of my components?

The ESlint extension in VScode encountered compatibility issues on the MacBook Pro 2021 powered by the Apple M1 Pro chip

Checking for Webpack has begun in a separate process - not found

Is it possible to derive a TypeScript interface from a Mongoose schema without including the 'Document' type?

Retrieve the value of the Type Property dynamically during execution

Troubleshooting problems with contenteditable and input in Firefox and Safari on Angular 5

A Typescript generic that creates a set of builder function interfaces

What is the best way to evaluate typing into an input field?

Expanding the session object with express-session

Converting a nested JSON object into a specific structure using TypeScript