In TypeScript, object types are used to define the shape of objects, specifying their properties, types, and structure. This enables type safety and autocompletion when working with objects. You can create object types using interfaces, type aliases, or inline annotations.

Defining Object Types

1. Inline Object Type AnnotationUse inline annotations to specify the structure of an object directly.

   typescript
   const person: { name: string; age: number } = {  name: "Alice",  age: 30,};
   

2. Using Type AliasesDefine reusable object types with type.

   typescript
   type Person = {  name: string;  age: number;};const person: Person = {  name: "Bob",  age: 25,};
   

3. Using InterfacesInterfaces are a common way to define object types and support inheritance.

   typescript
   interface Person {  name: string;  age: number;}const person: Person = {  name: "Charlie",  age: 35,};
   

Optional Properties

You can make properties optional using the ? modifier.

typescript
type Car = {  make: string;  model?: string; // Optional property};const car1: Car = { make: "Toyota" }; // Validconst car2: Car = { make: "Honda", model: "Civic" }; // Valid

Readonly Properties

Use the readonly modifier to make properties immutable after initialization.

typescript
type Book = {  readonly title: string;  pages: number;};const book: Book = { title: "TypeScript Handbook", pages: 300 };// book.title = "Another Title"; // Error: Cannot assign to 'title' because it is a read-only property.

Index Signatures

Use index signatures to define objects with dynamic keys.

typescript
type Dictionary = {  [key: string]: number;};const scores: Dictionary = {  math: 90,  science: 85,};// scores.english = "A"; // Error: Type 'string' is not assignable to type 'number'.

Nested Object Types

You can define nested object structures by combining types.

typescript
type Address = {  street: string;  city: string;  zipCode: string;};type User = {  name: string;  age: number;  address: Address;};const user: User = {  name: "David",  age: 40,  address: {    street: "123 Main St",    city: "Metropolis",    zipCode: "12345",  },};

Union and Intersection with Object Types

1. Union TypesAn object can conform to one of several possible shapes.

   typescript
   type Dog = { breed: string; bark: () => void };type Cat = { breed: string; meow: () => void };type Pet = Dog | Cat;const pet: Pet = {  breed: "Labrador",  bark: () => console.log("Woof!"),};
   

2. Intersection TypesAn object must conform to all specified shapes.

   typescript
   type Point = { x: number };type Labeled = { label: string };type LabeledPoint = Point & Labeled;const point: LabeledPoint = { x: 10, label: "Center" };
   

Type Inference with Objects

If TypeScript can infer the type of an object, you may not need explicit annotations.

typescript
const user = {  name: "Emma",  age: 28,};// TypeScript infers the type as { name: string; age: number }

Extending Object Types

1. Extending InterfacesUse the extends keyword to extend interfaces.

   typescript
   interface Animal {  name: string;}interface Dog extends Animal {  breed: string;}const dog: Dog = { name: "Buddy", breed: "Golden Retriever" };
   

2. Type Aliases with IntersectionsCombine types using &.

   typescript
   type Animal = { name: string };type Dog = Animal & { breed: string };const dog: Dog = { name: "Buddy", breed: "Labrador" };
   

Key Utility Types for Objects

TypeScript provides several utility types for working with objects:

1. Partial<T>Makes all properties optional.

   typescript
   type User = { name: string; age: number };type PartialUser = Partial<User>;const user: PartialUser = { name: "Alice" }; // Valid
   

2. Readonly<T>Makes all properties readonly.

   typescript
   type ReadonlyUser = Readonly<User>;const user: ReadonlyUser = { name: "Alice", age: 30 };// user.name = "Bob"; // Error
   

3. Pick<T, K>Selects specific properties from a type.

   typescript
   type NameOnly = Pick<User, "name">;const user: NameOnly = { name: "Alice" };
   

4. Omit<T, K>Excludes specific properties from a type.

   typescripttype WithoutAge = Omit<User, "age">;
   const user: WithoutAge = { name: "Alice" };
   

Best Practices for Object Types in TypeScript

1. Use interfaces for defining object types unless you need advanced features of type aliases.
2. Prefer readonly for properties that should not change after initialization.
3. Use utility types like Pick, Omit, or Partial to simplify type manipulation.
4. Enable strictNullChecks to avoid unexpected null or undefined values in objects.

Conclusion

Object types in TypeScript allow you to define structured, type-safe objects. They provide flexibility through interfaces, type aliases, utility types, and advanced features like unions and intersections. Understanding and effectively using object types can help you write more robust and maintainable code.