Guided: Object-oriented Programming with TypeScript Classes and Interfaces

Table of Contents

1. Challenge

   Introduction

   Welcome to this Code Lab on object-oriented programming (OOP) with TypeScript! OOP is a powerful paradigm for organizing complex software. It helps you create modular, reusable, and maintainable code by modeling real-world or abstract concepts as objects.

   In this lab, you will learn and apply the core pillars of OOP:

   • Classes and Objects: Blueprints and instances.
   • Inheritance: Creating new classes from existing ones.
   • Interfaces: Defining contracts for classes to follow.
   • Composition (via Dependency Injection): Building complex objects from simpler ones.

   You will build a flexible logging system, a common requirement in many applications, to see these concepts in action.

   ---

   If you are stuck or would like to check your implementations throughout the lab, feel free to refer to the solution directory. Keep in mind that you don't need to have the exact same solution for your work to be correct!

   This lab experience was developed by the Pluralsight team using Forge, an internally developed AI tool utilizing Gemini technology. All sections were verified by human experts for accuracy prior to publication. For issue reporting, please contact us.

2. Challenge

   Step 2: Creating a Basic Class

   A class is a blueprint for creating objects. It encapsulates data (properties) and behavior (methods). Your first step is to model a User by defining a class with properties to hold user data, a constructor to initialize it, and a method to describe it.

3. Challenge

   Step 3: Implementing Inheritance

   Inheritance is a fundamental OOP principle that allows you to create a new class (subclass) that reuses, extends, and modifies the behavior of an existing class (superclass). This promotes code reusability. You will now create an Admin user type that inherits from your base User class.

4. Challenge

   Step 4: Defining and Implementing Interfaces

   An interface is a powerful feature in TypeScript that defines a contract, specifying what properties and methods a class must have if it implements the interface. They are key to creating loosely coupled, extensible systems.

5. Challenge

   Step 5: Composing Classes with Dependency Injection

   Dependency Injection (DI) is a design pattern used to achieve Inversion of Control (IoC). Instead of a class creating its own dependencies, they are 'injected' from an external source. This makes your classes more modular, testable, and easier to maintain.

6. Challenge

   Step 6: Bringing It All Together

   Now that all the individual components are built, it's time to see them work in harmony. In this final step, you will instantiate the classes you've created and use them to perform a complete action: logging a message about an user's status. If you've successfully completed all the tasks, then you've completed the lab. You can display your class and interface implementations depicted in index.ts by running the command npm run start within the Terminal. It should have the following output:

   Admin action: ID: 1, Username: admin, Email: [email protected], Super Admin Status: false
   Admin action: ID: 2, Username: superadmin, Email: [email protected], Super Admin Status: true
   User action: ID: 3, Username: user, Email: [email protected] 
   

   Otherwise, feel free to modify or explore your code as you wish.