Master dependency injection to simplify testing and enhance your code's flexibility. Boost your development skills with this essential design pattern.

Dependency Injection (Solution)

[00:00] Okay, let's jump into this one. We've got our logger, we've got the email service which has a logger. We actually made it private this time. And it has the send email, so that all looks great. We added a console log here just so we can see some output because some of our fake stuff, does not show the console log.

[00:17] Spoiler alert. Okay. And then we've got our, mock logger. So this would be like a thing for testing purposes where we're going to store the messages rather than send them out to the console. So let's make a class, mock logger extends logger, and, we're going to store those logs.

[00:35] And my goodness, I just wish that AI would get on board with me. I do not like the non generic, version of array syntax. But, anyway, so we've got our logs we're gonna store, and anytime log is called, so, like, that's important. We're, extending logger. We're gonna override the log, function.

[00:54] Anytime log is called, we're gonna push that. And if we wanted to, we could say super dot log message and then we get both our implementation and the parent implementation done, but we're not gonna bother with that. And then, we're gonna call have it get logs so that you can assert, in your testing framework or whatever on these logs. Okay. Great.

[01:14] So let's just test this out. And we are getting test message when we call get logs. Awesome. Okay. That's what we want.

[01:21] And now we're going to use dependency injection with that logger. So we're gonna create the logger. Here, let's, comment those out. There we go. Gonna create the logger.

[01:31] We're gonna create the email service with that logger. And then, we're going to say send email and then we can get the logs and log the email service itself. And email service stores the logger as a private, instance, property. And so we don't have anything logging out as part of this object. We do have this, both of these logs.

[01:52] So this first one is coming from that console log that we added to send email. If I took that out, then that's gone. And then this one is the, log right here where we're saying get the logs. So then we could use that in some sort of testing scenario to say, hey, I said send an email. Did it log something?

[02:10] And you can make assertions on that. And the nice thing about this is that it doesn't actually write to a file system or it doesn't actually, log out to the console, and that's one of the benefits of being able to do this dependency injection. Now again, what is this really? It's just passing functions. But typically, what you would do without dependency injection is you would not accept the logger.

[02:34] You would instead have this be a new, what is it? Or, yeah, console logger instance or something like that. And so what dependency injection is is taking what you would naturally do and turn it into something that you can pass in as an argument. So then you can pass a fake version when you're testing. You can also, for the fun of it, we made a silent longer which does nothing.

[02:59] It does nothing at all. Yeah. And we can underscore so that that little underscore is a convention that that's not syntax or anything. It's just a little convention that says if, I I intentionally am not using this variable. So, you could also just not have that variable at all.

[03:17] That would work just fine too. So, yeah, then we'll use the silent logger, and there's nothing. Nothing is logged at all. Here. Let's get rid of this guy.

[03:27] Tada. Now there's nothing logged at all. So that would be a way to, like, maybe you wanna turn it off in a test environment or something like that. I don't know. Okay.

[03:36] Yeah. That's dependency injection. It literally is just passing arguments to a function, but it's pretty common, so wanted to show it to you. Hope you enjoyed it.

Dependency Injection

[00:00] Okay. In this one, we're actually gonna take the same example from before and we're going to expand it a little bit to talk specifically about a, pattern called dependency injection. Really, it's just basically like passing arguments to a function. That's all dependency injection really is, but it's a particular pattern that makes testing a lot easier and you're definitely going to see this in the industry. So we're gonna talk about it specifically, jump into this, finish that, and we'll see you when you're done.

Most modern JavaScript and TypeScript development leans heavily on functions and plain objects. But classes, interfaces, and inheritance aren't going away. You'll encounter them in libraries, frameworks, and codebases across the industry, and if you don't understand how they work, you'll struggle to work with the code that uses them.

The problem is that without a clear mental model, you'll misuse inheritance where composition would be simpler, skip interfaces where they'd save you from brittle coupling, and create class hierarchies that become impossible to follow three levels deep.

In this workshop, you'll learn how to build classes with proper encapsulation, implement interfaces for polymorphism, extend base classes when inheritance makes sense, and reach for composition when it doesn't.

Every section pairs the "how" with the "why," so you don't just learn the syntax, you learn when each pattern earns its place and when simpler alternatives are the better choice.

## Classes

Classes are the fundamental building block of object-oriented TypeScript. They bundle data and behavior together into a single unit-- a user has a name and email, a shopping cart has items and a total. If you've only worked with plain objects and functions, classes introduce a new way to organize your code.

In this section, you'll build classes from scratch while learning how they work under the hood:

- Creating classes with properties, constructors, and methods
- Using `new` to create instances and understanding what `this` refers to
- Initializing properties with default values instead of constructor arguments
- Making fields private with the `#` syntax to control access
- Refactoring constructors to accept an options object instead of positional arguments

## Interfaces and Classes

An interface on its own is just a shape-- a contract that says "anything claiming to be this type must have these methods." The real power shows up when multiple classes implement the same interface, because now you can write functions that accept any of them without knowing which specific class they'll get.

This section teaches you how interfaces enable polymorphism in practice:

- Defining interfaces with method signatures that classes must implement
- Using the `implements` keyword to enforce a contract on a class
- Implementing multiple interfaces on a single class
- Programming to abstractions by accepting interfaces instead of concrete classes
- Writing functions that work with any implementation of a given interface

## Inheritance and Polymorphism

Inheritance lets one class build on another. A circle is a shape. A square is a rectangle. The child class inherits everything from the parent and can override specific behavior-- like calculating area differently for each shape.

Here you'll work through the mechanics of inheritance and understand where it helps and where it hurts:

- Extending a base class with the `extends` keyword
- Forwarding constructor arguments to the parent with `super`
- Overriding methods to provide specialized behavior in child classes
- Using substitutability to pass any child class where the parent is expected
- Understanding why deep inheritance chains become difficult to maintain

## Composition vs Inheritance

Inheritance says "this thing is a that." Composition says "this thing has a that." A car isn't an engine-- it has one. The distinction matters because inheritance creates tight coupling between parent and child, while composition lets you swap out parts without rewriting the class that uses them.

This section shows you when to reach for each approach and why composition is usually the better default:

- Distinguishing "is a" relationships (inheritance) from "has a" relationships (composition)
- Injecting dependencies through constructor arguments instead of hardcoding them
- Swapping implementations at runtime by passing different objects (file logger, console logger, silent logger)
- Using dependency injection to make classes testable with mock objects
- Defaulting to composition and reserving inheritance for clear "is a" cases


Programming Foundations

Structured Data

Type Safety

Object Oriented TypeScript

Advanced TypeScript

Practical TypeScript: Foundations to Fluency

Master object-oriented principles in TypeScript, including classes, inheritance, and polymorphism, to enhance your development skills and project quality.

Intro to Object Oriented TypeScript

Introduction to Object Oriented TypeScript

Master TypeScript classes to enhance your object-oriented programming skills. Discover properties, methods, and best practices for efficient coding.

Intro to Classes

Master the fundamentals of object-oriented TypeScript by creating and implementing classes with essential properties and instances in this engaging exercise.

Class Basics

Master private fields and defaults in this exercise by creating a user class and secure bank account properties, enhancing your coding skills effectively.

Private Fields And Defaults

Boost your coding skills with effective break techniques that enhance retention and prepare you for the next challenge. Refresh and recharge your learning!

Break Classes

1. Classes

Master polymorphism with interfaces and classes, and discover how to implement multiple interfaces like flyable and swimmable in your projects.

Intro to Interfaces and Classes

Master interface implementation by creating a class that showcases its benefits, enhancing your coding skills and understanding of object-oriented design.

Implementing Interfaces

Master interface implementation and unlock powerful programming abstractions to enhance code flexibility and efficiency with this engaging exercise.

Programming To Abstractions

Master breaking interfaces and classes to enhance your coding skills, improve polymorphism understanding, and solidify your programming knowledge.

Break Interfaces and Classes

2. Interfaces and Classes

Master inheritance and polymorphism in OOP. Discover how to extend classes and override methods to create flexible, reusable code in your projects.

Intro to Inheritance and Polymorphism

Master class inheritance and polymorphism by exploring the extends keyword. Gain essential skills to elevate your coding proficiency today!

Extends

Master method overriding by exploring how shapes like circles and rectangles can redefine properties, enhancing your object-oriented programming skills.

Method Overriding 

Master polymorphism by creating a versatile media player that seamlessly plays audio and video files, enhancing your development skills.

Substitutability 

Master breaking inheritance and polymorphism in coding to enhance your programming skills, making your projects more efficient and adaptable.

Break Inheritance and Polymorphism

3. Inheritance and Polymorphism

Master the key differences between composition and inheritance in object-oriented programming to enhance your coding clarity and efficiency.

Intro to Composition vs Inheritance

Master the use of composition vs inheritance in classes. Discover when to apply has-a vs is-a relationships to enhance your coding skills.

When To Use

Master the differences between composition and inheritance in web development to enhance your coding skills and build more efficient applications.

Break Composition vs Inheritance

4. Composition vs Inheritance

Celebrate your mastery of Object Oriented TypeScript, from classes to polymorphism, and get ready to build amazing projects in the digital world!

Object Oriented TypeScript

Object Oriented TypeScript

Transcript

Dependency Injection

Transcript