Objects

Programming languages have a fascinating way of representing real-world entities. Just as you have objects in the real world like cars, books, and people, in TypeScript, you can represent these using a type known as the Object type. But what makes it so special, and how can you use it effectively in your TypeScript journey? Let's dive in!

What is an object?

In the broad realm of programming, an object can be visualized as a container holding related data and operations. Think of it like a backpack: it has multiple compartments (properties) and functionalities (methods). Similarly, in TypeScript, an object represents a collection of properties (values or functions).

The term object in TypeScript specifically refers to any non-primitive type. But wait, what's a non-primitive type? Remember data types like number, string, and boolean? These are primitive types. Everything that's not one of these primitive types can be labeled as an object.

Example:

const person: object = {
    name: "Alice",
    age: 30
};

In the above code, we define a constant person of type object. This object has two properties: name and age.

Object type annotation

In TypeScript, you have the flexibility to describe the shape of an object in more detail using type annotation. This ensures that the properties of the object adhere to the expected types.

Example:

type Student = {
    studentID: number;
    studentName: string;
};

const student1: Student = {
    studentID: 101,
    studentName: "Bob"
};

Here, we've defined a new type Student that has two properties: studentID of type number and studentName of type string. This allows us to have strongly typed objects and reduces potential errors in our code.

When defining an object that adheres to a specific type, TypeScript will raise a compilation error if the object contains properties that aren't expected for that type. This acts as a safety measure, ensuring the integrity of our data structures.

type Animal = {
    name: string;
    age: number;
};

const dog: Animal = {
    name: "Buddy",
    breed: "Golden Retriever" // Error: Object literal may only specify known properties, and 'breed' does not exist in type 'Animal'.
};

In the above code, we've defined an Animal type expecting properties name and age. However, when we try to assign an object with an additional property breed to the dog constant of type Animal, TypeScript flags this as an error. This ensures that we don't accidentally introduce unwanted properties and helps maintain the structure of our objects.

Special object types

TypeScript comes with some built-in object types that you might come across, such as:

• Array: Represents a collection of elements. It can be annotated like: number[] or Array<number>.
• Tuple: Allows you to express an array with a fixed number of elements whose types are known.
• Enum: A way to give friendly names to sets of numeric values.

Example:

type Pair = [number, number]; // This is a Tuple

enum Colors {
    Red,
    Green,
    Blue
};

In this code, Pair is a tuple that expects two numbers, while Colors is an enum representing three color values.

Practical usage of custom object types

Using custom object types in TypeScript helps model real-world scenarios efficiently. Let's dive into how to leverage these for better coding practices.

Creating and using custom types

Consider a library system:

type Book = {
    title: string;
    author: string;
    publishDate: Date;
};

const myBook: Book = {
    title: "TypeScript Mastery",
    author: "John Doe",
    publishDate: new Date('2022-01-01')
};

Here, the Book type ensures every book object adheres to the defined structure.

Extending object types

TypeScript allows extending types for specialized subtypes:

type Media = {
    title: string;
    publishDate: Date;
};

type Book = Media & { author: string; };
type Movie = Media & { director: string; duration: number; };

Book and Movie types inherit properties from Media but also have unique attributes.

Common patterns

• Optional properties: You can mark properties as optional using the ? modifier. This indicates that the property can be left out when creating objects of this type. In the next code, the age property is optional. Therefore, both the john and alice object declarations are valid, even if john does not have the age property.

type Person = { name: string; age?: number; };

const john: Person = { name: "John" }; // This is valid, even if 'age' is omitted
const alice: Person = { name: "Alice", age: 25 }; // This is also valid

• Read-only properties: Use the readonly modifier to ensure a property remains unchanged after its initial assignment. In the serverConfig example, once the apiUrl is set to "https://api.example.com", trying to modify it later will result in a TypeScript error. This helps ensure the immutability of certain properties where needed.

type Config = { readonly apiUrl: string; };

const serverConfig: Config = { apiUrl: "https://api.example.com" };
// serverConfig.apiUrl = "https://api.newurl.com";  // Error: Cannot assign to 'apiUrl' because it is a read-only property.

Conclusion

In TypeScript, the Object type forms the bedrock of structured, robust coding. Objects, as non-primitive types, encompass a wide array of data structures beyond just the basic number, string, and boolean. With the addition of type annotations, TypeScript ensures our objects adhere to a predefined shape, enhancing code predictability. Special object types, like Arrays and Enums, add granularity, while custom types offer versatility, enabling us to mirror real-world scenarios. By using and extending these types, alongside patterns such as optional and read-only properties, developers can craft precise and adaptable code. As you delve deeper into TypeScript, keeping these Object-type principles in mind will guide you toward more efficient and type-safe programming.