Master string enums in TypeScript through a hands-on order management system exercise and enhance your coding skills for better type safety.

String Enums 

[00:00] Okay. Let's jump into this. So we've got this order management system, so we're gonna make an enum that is, order status enum. This looks a little bit like a type except there's no equals, so it looks a little bit more like an interface, but then there's these equal signs here. So it's just a completely different thing by itself.

[00:16] These values can be strings. They can be numbers. They can be, billions of true and false. Just kidding. Can't be billions.

[00:28] So really just a number or a string. That's your only option. Okay. Great. And there we go.

[00:34] Keep on undoing and stuff. Alright. So then we can make an order. Let's actually make a type for order. So the status is gonna be one of those order statuses.

[00:45] And so then when we make an order object, order order, there we go, we have our status right here. Now, you cannot cannot, just use the value of that, enum. You have to reference the enum itself. Also, yeah, not the name of the enum. That also doesn't work.

[01:04] You have to use the order status, dot and then, the it'll give you a selection of these things. We're gonna say, pending. We don't need to ask order status. That works fine. Okay.

[01:17] Great. So now, that we've got that, let's go ahead and we'll console log our order. Looks awesome. Let's make a get, status message thing that handles all of our different cases here and we'll console log that and also let's export our stuff here. And we've got our, status.

[01:36] So your order is pending. Tada. It works just fine. I've got some some beef with enums that we're not gonna talk about here, but or we'll talk about one of them, and we'll cover the other one in our next step here. But, yeah.

[01:52] The the big beef I have with this is if you take a look at the compiled code of, of this code here, then you'll see what it does, what TypeScript has to do to support enums. It's this piece right here. That maps to our, enum stuff right here. So, the reason I don't like this is because it's a TypeScript only feature that actually generates run time code. So this is the code that's actually going to run-in the browser or in whatever environment you're running your your, JavaScript in.

[02:27] You write TypeScript, it compiles into this. But, everything else that's TypeScript only gets compiled away, just just disappears. So we've got our order status right here. That's gonna disappear. You've got your, let's see.

[02:42] What else is specifically type yeah. Most of it's actually not TypeScript. Most of this is, here. Let's let's grab our example. There we go.

[02:52] So we've got this order thing right here. That gets compiled away. So all the TypeScript specific stuff just goes away. I like that a lot. I I want TypeScript to be one thing and then all of the, the JavaScript stuff to just hang around and TypeScript just kinda melts away.

[03:09] But enums are different. Enums will actually generate run time code, and I just don't like that. It feels it feels wrong. Feels wrong to me. I don't I'm not a huge fan of that.

[03:18] So that's one reason that I don't like enums. The other reason is that, like, their benefits are annoying. So we'll look at that here in the next step. But, hopefully, this at least gives you a sense for how to use enums. You create it like this and then you reference it everywhere you go, so that you're able to, track where those things are being used.

[03:42] Okay. Great. Well done on this one. We'll see you in the next.

String Enums

[00:00] Alright. Now we're gonna learn about enums and it's just particularly string enums. You also have, numbers and booleans and stuff, but, enums are interesting, and you're going to learn about them here. We've got a order management system that you're gonna use. So let's get into it, and we'll see you when you're done.

In TypeScript, every variable, every function parameter, every return value carries a type. When those types are wrong, you get bugs that surface at the worst possible moment. Runtime crashes, silent data corruption, and hours spent debugging issues that the compiler could have caught before you ever hit save.

The problem is that you haven't built the mental model for how its type system actually works. You annotate a few variables, sprinkle in some `any` when things get frustrating, and move on, never realizing you've turned off the very safety net that makes TypeScript worth using.

The Type Safety Workshop takes you deep into TypeScript's type system. You'll learn how to model your data precisely with type aliases, union types, and generics, then use that precision to catch entire categories of bugs at compile time instead of in production.

In this workshop, you'll work through real patterns like discriminated unions for API responses, type guards for runtime narrowing, and `as const` for deriving types from your source code, the same techniques used in production TypeScript codebases every day.

## Type Aliases

Every time you duplicate a type annotation across multiple variables or functions, you're creating a maintenance problem. Change the shape in one place, forget the other, and you've got a type mismatch that might not surface for weeks. Type aliases let you define a type once and reference it everywhere.

In this section, you'll create reusable types and learn how to compose them from smaller building blocks:

- Creating type aliases for objects with `type User = { id: string; name: string }`
- Using `typeof` to derive types from existing runtime values
- Composing types from primitive aliases like `ID`, `Timestamp`, and `Email` to communicate intent
- Using `Record` to type objects with dynamic string keys
- Choosing between explicit type definitions and inference with `typeof`

## Union Types

Real application data is rarely just one thing. An API response might be a success object or an error. A user ID might be a string or a number. Without union types, you're forced to use `any` or write separate functions for every possible shape-- neither of which scales.

This section covers one of TypeScript's most powerful features and the patterns that make it practical:

- Defining types that accept multiple shapes with the `|` operator
- Narrowing unions with `typeof` and `instanceof` checks
- Using the `in` operator to distinguish between object shapes
- Writing custom type guard functions with the `value is Type` syntax
- Building discriminated unions with a shared status or type property
- Exhaustive checking with `switch` statements and the `never` type

## Literal Types

TypeScript infers `const x = "hello"` as the literal type `"hello"`, but `let y = "hello"` becomes just `string`. That distinction matters more than you'd think-- especially when you want your types to reflect the exact values in your code rather than broad categories.

Here you'll learn how to preserve and leverage literal types in your programs:

- Using `as const` to preserve literal types on objects and arrays
- Deriving union types from object keys with `keyof typeof`
- Extracting value types from constant objects for precise unions
- Building a single source of truth where types flow from runtime values
- Practical patterns like typed route maps and discriminated return types

## Intersection Types

Union types let a value be one of several shapes. Intersection types go the other direction-- combining multiple types into one that has all their properties. It's the type-level equivalent of spreading objects together.

This section teaches you how to compose types from reusable pieces:

- Combining types with the `&` operator to build composite shapes
- Creating reusable building blocks like `WithID`, `WithTimestamps`, and `WithAuthor`
- Assembling entity types (`User`, `Post`, `Comment`) from shared base types
- Understanding how intersection differs from union in practice

## Any vs Unknown

When TypeScript gets in your way, it's tempting to reach for `any` and move on. The problem is that `any` doesn't just silence one error-- it turns off type checking for everything that value touches. It's an escape hatch that defeats the purpose of using TypeScript in the first place.

This section shows you the safer alternative and when each escape hatch is appropriate:

- Understanding why `any` disables all type checking on a value
- Using `unknown` as a type-safe alternative that requires narrowing before use
- Narrowing `unknown` values with `typeof` checks and error throwing
- Processing values of different types through runtime checks
- When you'll encounter `any` in library code and why it exists for backward compatibility

## Generics

Without generics, you'd need a separate function for every type you want to support-- `firstNumber`, `firstString`, `firstUser`-- or you'd give up and use `any`. Generics let you write a single function that works with any type while preserving full type safety through the entire call chain.

This section takes you from basic generic syntax through real-world patterns with constraints:

- Writing generic functions with type parameters (`<Value>`)
- Letting TypeScript infer generic types from function arguments
- Creating generic types for reusable patterns like loading states
- Constraining generics with `extends` to require specific shapes
- Building a type-safe `getProperty` function using `keyof` constraints
- Merging objects with fully typed intersection return values

## Interfaces

Interfaces look almost identical to type aliases-- and for most purposes, they behave the same way. So why do they exist? Historical reasons, mostly. But interfaces have one unique capability that types can't replicate: declaration merging.

Here you'll learn when interfaces matter and when to stick with types:

- Defining object shapes with `interface` syntax
- Extending interfaces to build up from base types
- Understanding declaration merging and how interfaces combine across modules
- Augmenting global interfaces for plugin systems and library configuration
- Why types are preferred for day-to-day code and when interfaces earn their place

## Enums

Enums give you a way to define a set of named constants-- `OrderStatus.Pending`, `OrderStatus.Active`, `OrderStatus.Completed`. They're one of the few TypeScript features that generate actual runtime code, which makes them unique in the type system and controversial in the community.

In this section, you'll learn how enums work and why union types are often the better choice:

- Creating string enums for order statuses and log levels
- Using enums in switch statements and type-safe functions
- Understanding the runtime code that enums generate after compilation
- Migrating from enums to union types for simpler, cleaner code
- Comparing the developer experience of enums vs. unions for autocomplete and type safety


TypeScript's type system: learn type aliases, unions, generics, intersections, and more to catch bugs at compile time instead of in production.

Type Safety

Programming Foundations

Structured Data

Object Oriented TypeScript

Advanced TypeScript

Practical TypeScript: Foundations to Fluency

Master TypeScript's type safety and enhance your coding skills with practical exercises on type aliases, generics, and more. Dive into advanced concepts today!

Intro to Type Safety

Introduction to Type Safety

Master Type Aliases in TypeScript to simplify your code, enhance reusability, and effectively manage complex data types with ease.

Intro to Type Aliases

Master TypeScript by creating and using type aliases to enhance your coding efficiency and clarity in this hands-on workshop.

Naming Types

Master type composition by creating effective type aliases for primitives and objects, enhancing your TypeScript skills for cleaner, more maintainable code.

Composition

Master record types and generics in this engaging exercise, enhancing your object handling skills for dynamic applications. Dive in and elevate your coding expe

Record Type

Break Type Aliases

1. Type Aliases

Master TypeScript union types to enhance your coding skills. Discover how to manage multiple types effectively and streamline your logic.

Intro to Union Types

Master union types in this exercise by working with strings, errors, and numbers to enhance your TypeScript skills and streamline your functions.

Multiple Types

Master TypeScript type guards and user handling to efficiently manage strings and arrays, enhancing your JavaScript coding skills today!

Narrowing

Master type guards in TypeScript to streamline type checking and enhance your code's reliability. Create custom functions for effective type validation.

Type Guards

Master the discriminated unions pattern in TypeScript to enhance your coding skills and streamline complex data handling in your applications.

Discriminated Unions

Master union types and type narrowing in this engaging lesson, enhancing your coding skills and retention while enjoying a light-hearted approach.

Break Union Types

2. Union Types

Master literal types in TypeScript by leveraging 'as const' for type safety and precision. Enhance your coding with powerful type narrowing techniques.

Intro to Literal Types

Master literal preservation with the as const keyword and enhance your TypeScript skills, ensuring type safety and precision in your code.

Preserve Literals 

Master the concept of a single source of truth by deriving types from code using as const, enhancing your TypeScript skills and code accuracy.

Single Source Of Truth 

Master breaking literal types to enhance your coding skills, boost retention, and build robust applications. Dive in and elevate your development game!

Break Literal Types

3. Literal Types

Master intersection types by combining multiple types effortlessly. Enhance your TypeScript skills and streamline your coding with practical examples.

Intro to Intersection Types

Master intersection types in TypeScript to enhance your coding skills and streamline your development process. Join us to unlock powerful type combinations!

Combining Types 

Master intersection types in web development while enjoying a refreshing break. Boost your skills and retain knowledge effectively for real-world applications.

Break Intersection Types

4. Intersection Types

Master the differences between Any and Unknown in TypeScript to enhance your coding skills, improve type safety, and optimize your development process.

Intro to Any vs Unknown

Master the nuances of JavaScript's "any" vs. "unknown" types and enhance your coding skills with practical insights in this engaging exercise.

Escape Hatches 

Master the concepts of breaking any and unknown variables, boost your coding skills, and unlock your potential as a developer in this engaging lesson.

Break Any vs Unknown

5. Any vs Unknown

Unlock the power of TypeScript generics to create flexible, type-safe functions that work with any data type. Enhance your coding skills today!

Intro to Generics

Master generic functions by creating two practical examples, enhancing your coding skills and understanding of syntax for real-world applications.

Generic Functions 

Master generic types in programming with practical examples and enhance your coding skills to create more flexible and reusable code.

Generic Types

Master advanced generics in programming by exploring constraints that enhance type safety and streamline function usability. Unlock powerful coding techniques n

Constraints

Master generics in web development and boost your coding skills with practical exercises and insights that enhance your programming efficiency.

Break Generics

6. Generics

Master interfaces in web development and discover their unique advantages, including declaration merging and practical syntax. Elevate your coding skills now!

Intro to Interfaces

Master object shapes with interfaces in this hands-on exercise, enhancing your TypeScript skills and building robust, type-safe applications.

Object Shapes 

Master interface extension in TypeScript and enhance your coding skills by combining types effectively with the extends keyword. Join us now!

Extending Interfaces 

Master declaration merging in TypeScript interfaces across modules and unlock powerful library design techniques for your projects.

Declaration Merging 

Revitalize your coding skills with a refreshing break! Discover the importance of posture and movement for enhanced focus and productivity in development.

Break Interfaces

7. Interfaces

Master enums with this concise guide, exploring their syntax, unique values, and practical applications to enhance your coding skills effectively.

Intro to Enums

Master the differences between enums and unions while migrating your code. Discover why unions may be the better choice for your development projects.

Enum Vs Union 

Master enum concepts and enhance your coding skills with practical exercises and retention techniques to boost your development knowledge effectively.

Break Enums

8. Enums

Congratulations on mastering type safety! Solidify your skills with practical examples and build your confidence in TypeScript's powerful features.

Type Safety

Type Safety

Transcript

String Enums

Transcript