Do interfaces in Typescript require nested properties to be mandatory?

Question

Do interfaces in Typescript require nested properties to be mandatory?

My interface contains a nested object:

export interface Person {
    PersonWrapper: {
        name: string;
        address: string
        email?: string;
    }
}

When attempting to create an object from this interface, it appears that name is not mandatory, although it should be. The interface does not specify it as an optional property. Below is how I attempt to create the object:

const payload = {
    PersonObj: {
        address: '123 memory lane'
    }
} as Person;

Why am I not receiving a compile-time error indicating that name is required? If I omit wrapping it in PersonWrapper, then I receive an error for sure.

typescript

Answer 1

Answer №1

By opting for type assertion over type annotation in your code, the compiler considers you to be close enough to the expected Person structure and does not flag missing properties as errors. To resolve this issue, it is recommended to utilize type annotation instead:

// expected error
const payload: Person = {
  PersonWrapper: {
    address: "123 memory lane",
  },
};

For a more detailed explanation on the disparity between type annotation and assertion, refer to this article

Answer 2

By opting for type assertion over type annotation in your code, the compiler considers you to be close enough to the expected Person structure and does not flag missing properties as errors. To resolve this issue, it is recommended to utilize type annotation instead:

// expected error
const payload: Person = {
  PersonWrapper: {
    address: "123 memory lane",
  },
};

For a more detailed explanation on the disparity between type annotation and assertion, refer to this article

Answer 3

Answer №2

When it comes to TypeScript, there are two main ways to indicate types:

Type Annotation
```
let name: string;
```
Type Assertion
```
let name = getSomeValue() as string;
```

According to the TypeScript documentation, type assertion is more lenient compared to type annotation which is stricter:

In TypeScript, type assertions can only convert to a more specific or less specific version of a type. This rule prevents any "impossible" coercions.

SOURCE: https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#type-assertions

Answer 4

When it comes to TypeScript, there are two main ways to indicate types:

Type Annotation
```
let name: string;
```
Type Assertion
```
let name = getSomeValue() as string;
```

According to the TypeScript documentation, type assertion is more lenient compared to type annotation which is stricter:

In TypeScript, type assertions can only convert to a more specific or less specific version of a type. This rule prevents any "impossible" coercions.

SOURCE: https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#type-assertions

Do interfaces in Typescript require nested properties to be mandatory?

Answer №1

Answer №2

Similar questions

Is there a way to automatically extend my content to fill the space on the page below the Material UI AppBar?

Is it possible to determine the type of an array value similar to how we can determine the type

While running tslint in an angular unit test, an error was encountered stating 'unused expression, expected an assignment or function call'

When the property "a" is set to true, it must also require the properties "b" and "c" to be included

Encountering an Issue with Typings Installation in Angular 2 and Algolia Search

Exploring Tailwind's flexibility with custom color schemes

What is the method for defining a mandatory incoming property in an Angular2 component?

Conditional Return Types in a Typescript Function

VIDEOJS ERROR: A peculiar mistake has occurred. TypeError: The property 'value' cannot be read since it is undefined in the context of

Is there a way to identify which elements are currently within the visible viewport?

Leverage Ramda's clone function within a pipeline in a manner that ensures type safety

TS1086: Attempting to declare an accessor within an ambient context is not allowed

What causes the discrepancy in values displayed by enums in TypeScript when assigned integers in reverse order?

How to Hide Parent Items in Angular 2 Using *ngFor

Enhancing Angular2 authentication with Auth0 for enabling Cross-Origin Resource Sharing

Typescript, creating multiple definitions for a function with an object parameter

Typescript implements strict enforcement of partial interfaces

Encountered an Angular 2 error: NullInjectorError - Http provider not found

Navigating through an Angular 2 service

I possess both a minimum and maximum number; how can I effectively create an array containing n random numbers within