Master switch statements in programming. Simplify code logic, enhance readability, and boost efficiency with this essential guide.

Switch Statements

[00:00] Alright. Let's get into it. So we're going to start with our description. This is the thing that we're going to, describe the the letter grade. So based on the different, letters that are, that are available, we're going to describe it.

[00:13] And like I said, you should be looking for opportunities to get rid of that explicit typing, in my opinion because it just makes your code a little bit nicer. So I do throw in the, explicit types occasionally in here, but look for opportunities that you can get rid of that. In our case with the description, we're not going to assign it to anything, right from the get go. So having an explicit type makes a lot of sense there. Alternatively, you could say, unknown right here because our description is, yeah, unknown grade.

[00:46] That would work. And now TypeScript does know that it is a string and will only allow us to assign it to a string. So if I try to say, assign it to some number or something, it's gonna blow up on me. So however you wanna do that, I'm gonna just do it's not assigned. It's gonna be of type string, though.

[01:04] And now we get into the switch statement. So the thing that we're going to be evaluating is the grade. If the grade is this, if the grade is that, if the grade is this, if the grade is that, if you're doing something like that, then you can feel free to use if else statements, but you might be better served by a switch statement. So the switch, is going to switch on the grade. And here, we're going to say if, the grade is a so here, we're actually getting a red underline, not comparable to type b.

[01:33] Oh, Yeah. That's interesting. That is why we actually need this. I forgot. We do need, this sometimes.

[01:41] Let me think if I want to share exactly why at this stage. We're gonna get deeper into types in a future exercise, in a future workshop. So if this bit doesn't totally make sense to you, then just stand by. We'll get to more advanced typings here in a future workshop. But I'll just briefly explain.

[02:00] By assigning grade to b, TypeScript knows, hey, this is a const. It could only possibly ever be the value of b. And so here our switch statement is like, hey, why are you switching on whether grade is a? Because it couldn't ever possibly be a unless you were to go and actually change the code. But now we're gonna say, hey, it can't possibly be b.

[02:20] There's nothing in your code that changes it to b. So, we want to, compare b, but we also want to have our switch statement do this so we can experiment. And so what, we're doing when we do type string is we're saying, hey, grade can be any string. And TypeScript's like, oh, okay. So it is not necessarily always going to be b.

[02:41] You're saying it can be any kind of string. And so what we're doing here is effectively called type widening, and that's what is gonna make what we're trying to do work as we're kind of experimenting with things. Most of the time in a real world program, if you have hard coded values like this, you don't wanna do this and you do wanna just listen to the warnings that you're getting in TypeScript. Oh, it couldn't possibly be a? Well, then why am I doing that?

[03:09] Right? But in our case, we're playing around with things. We are going to be changing the value, of the grade and stuff, just through the hard coded value here. And And so we're gonna just widen the type. Say, it's not just the string b, but it's a wider version of that.

[03:24] It's a any string possibly. Okay. Great. Thanks for that little detour and, let's continue. We've got our grade.

[03:33] If the grade is a, then our description is gonna be excellent, and then we're going to break. What that does, or or, to understand break, you need to understand what happens if we don't have break here. Yeah. We'll go ahead and let that go. So if we don't have break here.

[03:49] Actually, you know what? Let's do this. We'll get rid of all of the breaks, and we'll see what happens. Let's console log, and then we'll export. So here we go.

[04:02] We've got, that is actually unexpected. What's going on here? Yeah. We got our log grade b. Oh, There we go.

[04:12] Yeah. That see, it's confusing. So, our grade is b, and then our description is invalid grade. But that's interesting because here we're saying if the grade is b, the description should be good. What's going on here?

[04:28] Well, what happens with the switch statement in particular is, the case basically, is the entry point for where, the the code can start evaluating, with this indentation here. So, right here, or I guess we start right here, we enter into this, case waterfall. I don't know. Nobody calls it a waterfall. I just made that up.

[04:51] But, we start into, the case code at case b. And so then it evaluates this. And then from there on, it actually just will cascade down into the next cases automatically. That's the default behavior. So we turn this default behavior off by adding a break to each one of these cases.

[05:14] And so now, it's going to say, okay. Well, we get into case b. I'm gonna evaluate this code and then it says break. Oh, okay. Let me break out of this switch statement.

[05:24] We'll skip the rest of it. So we'll evaluate this stuff. We'll hit the break and be like, ah, breaks. Let's get out of here, and we continue on with the rest of this code. And so then that gives us a grade of b good.

[05:36] So b good. So that is one one aspect of switch statements I wanna do. The other one is some of your AI, assistants may have added curly braces to each one of these things. And this actually comes down to, something called closures, which we or, yeah, this isn't closures actually. This is blocks.

[05:59] And that's not really something that we have discussed in, what we've talked about so far. And I don't have an exercise specifically about this. We do talk about closures which is functions and stuff. We'll talk about that later. But these code blocks are useful if you want to have some variables defined inside of this block of code.

[06:20] So let's get rid of those. We'll talk briefly what that is all about, and then we can continue with our lives. So, let's say I wanted to say, let's, let's see. My favorite number is 42. And then I wanna say let my favorite number is 42 here as well, and we'll say, excellent.

[06:41] My favorite number. We'll put this in a tech template literal. So we're actually using this just to make it more interesting. Good, my favorite number, etcetera. Okay.

[06:47] So we're getting red underlines. And the reason that we're getting these red underlines is because we cannot redeclare blocked scope variables. So let and const are both blocked scoped variables. And in fact, so let's switch these to const because we're not reassigning them. We're gonna get the same error.

[07:04] So what's going on here is, this would be the same as if we were to move this right up here. That's not gonna work. Right? Because we're re declaring const. We could actually even do the same with let because we can't every time you do a let description or a var description or a const description, That is called a declaration for the variable.

[07:28] You cannot do that multiple times. You can only do it once. But if you put them inside of a block, you can. So we could actually put a block right here and a block right here, and now everything is is happy, fine, everything's good because this variable only exists in the context of these curly braces. And so if you want to, have some variables that are scoped down to just a particular case, you can wrap that in curly braces and that's actually a really common thing to do.

[07:59] And in fact, I pretty much always have my switch statements use curly braces. All the cases use curly braces to avoid, this exact issue. So I'm gonna do that right now and we're gonna, maybe remind the LLM that, hey, we want to have curly braces around all of our cases because it's just a little bit better hygiene. Okay. Great.

[08:22] I think there's one other thing I wanted to mention as I clean this up, and that is, switch statements are, not exactly terse, so at least in how long they get. So let's take a look at a comparison between this and the, the if else version of this. So if I said, if grade, etcetera, etcetera. K? So we've got our grade a, b, c.

[08:51] There if we look at this, we're looking at, what is that? 12 lines of code, and then here it's 22 to 47. So it's like quite a bit more code. What what is that? Like, 50% or more 75% more code, at least as far as lines of code is concerned.

[09:09] And you've got some repetition with the break and stuff. But the thing that I really like about the switch statement is that I don't have a possibility of making some sort of error like this. Now, TypeScript's gonna help me avoid this type of error. But if you just look at it visually, you might not notice because there's just a lot of noise going on here between each one of these. Or if I were to forget an, an else right here, you might not notice because there's just a lot of code going on here.

[09:38] Now luckily for us, we've got some tools like Prettier and TypeScript that can kinda help us with this, and that puts it on a new line. It kinda breaks things up a little bit. But my point is that, this comparison is done automatically for us by the switch statement, and that's kind of that's kinda nice. I kinda like that. So, when I can use a switch statement, I typically will use the switch statement, unless it's really a simple if else, sort of situation.

[10:06] Typically, when they're in programming, there's often more than one way to do a thing. I will often do both and then look at them and be like, which one do I hate the least? And choose that one. Alright. There you go.

[10:20] That is switch statements. We're, controlling our flow of our program. Hope you enjoyed that one. We'll see you in the next one.

[00:00] Let's get into, switch statements. This is another control flow, feature of JavaScript and many other languages. And effectively, what this is is in our if else example, we were basically just saying, the score, and and every single one of our if statements was evaluating whether the score was greater than or equal to some value. Switch statements are, kind of specially catered to that type of, scenario. So here's the value.

[00:29] And in this in the case that it's this, then do this. In the case that it's this, then do this, etcetera, etcetera. So if statement's definitely more powerful. Switch statements, are a little bit more niche, but, very useful and a little bit easier to read in some cases as well. So you're definitely going to run into them in the real world, and so we're gonna learn about them in this exercise.

[00:48] I'll leave you to it. We'll see you when you're done.

Learning to program can feel overwhelming. There are countless tutorials, boot camps, and YouTube videos all pulling you in different directions, and most of them assume you already know something.

The result? Gaps in your understanding that haunt you for years. You memorize syntax without understanding what it means. You copy-paste code that works but can't explain why. When something breaks, you're stuck because you never built the mental model to reason about what's happening underneath.

The Programming Foundations Workshop is your ground-zero start to becoming a software developer. Built with TypeScript from the very first line, it takes you from zero prior programming experience through expressions, variables, types, functions, and beyond-- equipping you with the foundational knowledge that every concept in web development builds on.

No prior programming knowledge is required. If you can open an editor and run the workshop app, you're ready. And because this is how software is built today, you'll learn alongside AI-assisted tooling from the start-- building the skills to write, review, and understand code in a modern development workflow.

## Expressions & Output

Every program needs a way to tell you what it's doing. Without output, you're flying blind-- writing code with no way to verify it works. This is the very first skill you need as a developer.

In this section, you'll get your programs talking back to you while learning the building blocks of every piece of code you'll ever write:

- Outputting values with `console.log`
- String expressions and concatenation
- Number expressions and arithmetic operators
- Escaping special characters in strings
- Template literals with interpolation and multiline support

## Variables

Hardcoded values can only get you so far. Real programs need to store, reference, and update data as they run. Without a solid understanding of how variables work, you'll constantly be confused by unexpected behavior.

Variables are foundational to every program you'll ever write. Here you'll learn how to declare them, when to use each type, and a critical nuance that trips up even experienced developers:

- Declaring variables with `let` and `const`
- Naming conventions and casing (camelCase, SCREAMING_SNAKE_CASE)
- Reassigning values with `let` and compound operators like `+=`
- The important distinction between reassignment and mutation
- Why `const` doesn't always mean the value can't change

## Primitive Types

JavaScript has types whether you think about them or not. Every value in every variable carries a type, and ignoring that fact leads to bugs that are hard to track down. TypeScript makes these types explicit, catching entire categories of errors before your code ever runs.

This section introduces you to all seven primitive types and how TypeScript helps you work with them safely:

- Explicit type annotations with `number`, `string`, and `boolean`
- The difference between `null` and `undefined`
- Special types: `bigint` for arbitrarily large numbers and `symbol` for unique identifiers
- Type coercion and why it can surprise you
- Floating-point precision and practical considerations for working with numbers

## Comparisons & Boolean Logic

Making decisions is at the heart of every program. Should this button be enabled? Does this user have access? Is the cart empty? All of these questions boil down to comparisons and boolean logic.

Getting comparisons wrong leads to subtle bugs that are painful to debug. This section gives you the tools to write conditions that behave exactly as you'd expect:

- Loose equality (`==`) vs. strict equality (`===`) and why you should almost always use strict
- Not-equal, greater-than, and less-than-or-equal-to operators
- Combining conditions with logical AND (`&&`), OR (`||`), and NOT (`!`)
- Order of operations with logical operators
- Using parentheses to make complex conditions explicit

## Truthiness & Falsiness

JavaScript has a unique feature where every value has an inherent "truthiness" or "falsiness." This isn't a bug-- it's one of the most practical features of the language once you understand it. But misunderstanding it leads to some of the most confusing behavior new developers encounter.

Here you'll learn which values are truthy, which are falsy, and how to use this knowledge to write cleaner conditional logic:

- Coercing values to booleans with the `Boolean` constructor
- The double-not (`!!`) operator and when to use it
- Falsy values: `0`, `""`, `null`, `undefined`, `false`, and `NaN`
- Practical patterns like checking array length and optional values
- Avoiding common pitfalls with logical operators and coercion

## Functions

Up to this point, your programs run top to bottom and that's it. Functions change everything. They let you take a chunk of code, put it somewhere reusable, and call it from anywhere-- with different inputs each time.

Functions are the single most important building block for organizing and scaling your programs. This section takes you from writing your first function through passing functions as arguments to other functions:

- Function declarations with the `function` keyword
- Accepting parameters and specifying their types
- Return values and TypeScript's return type inference
- Arrow functions and implicit returns
- Passing functions as arguments to other functions
- Documenting your functions with JSDoc

## Type Inference & Arrow Functions

TypeScript is smart. You don't have to type everything explicitly-- TypeScript can often figure out the types for you by looking at your code. Knowing when to lean on inference and when to be explicit is a skill that makes your code cleaner and your development faster.

This section also covers arrow functions, a concise alternative syntax you'll see everywhere in modern JavaScript and TypeScript:

- How TypeScript infers return types from your function body
- When explicit return types help catch bugs earlier
- Converting function declarations to arrow functions
- Implicit returns for single-expression functions
- The hoisting difference between declarations and expressions
- Function expressions as first-class values

## Void & Never

Not every function returns something useful, and some code paths should never be reached. TypeScript has dedicated types for both of these situations, and understanding them helps you write more precise, self-documenting code.

This section introduces two TypeScript-specific concepts that complete your understanding of the type system's fundamentals:

- The `void` type for functions that don't return a value
- How `void` relates to `undefined` in practice
- The `never` type for functions that throw errors or never return
- Using `never` to enforce exhaustive checks
- Throwing errors to halt execution and signal failures
- Practical patterns for input validation with error throwing

Programming Foundations

Structured Data

Type Safety

Object Oriented TypeScript

Advanced TypeScript

Practical TypeScript: Foundations to Fluency

Master programming basics with our Introduction to Programming Foundations. Perfect for beginners eager to start coding and build essential skills.

Intro to Introduction To Programming Foundations

Introduction to Programming Foundations

Intro to Expressions And Output

Hello World

Escaping Strings

Strings

Numbers

Template Literals

Discover the art of taking effective breaks to boost productivity and mental clarity. Learn techniques to recharge and enhance focus in your daily routine.

Break

1. Expressions And Output

Intro to Variables

Discover the key differences between let and const in JavaScript. Optimize your code with these essential ES6 variable declarations.

Let And Const

Explore the key differences between reassignment and mutation in programming. Enhance your coding skills with clear insights and practical examples.

Reassignment Vs Mutation

Discover effective strategies to break bad habits and boost productivity. Transform your routine with actionable tips for lasting change.

Break Variables

2. Variables

Discover the basics of primitive types in programming. Understand integers, floats, booleans, and more to enhance your coding skills.

Intro to Primitive Types

Master numbers and strings with this guide. Enhance your coding skills by understanding data types and their applications in programming.

Numbers And Strings

Discover key differences and similarities with our in-depth comparisons. Make informed decisions with clear insights and expert analysis.

Comparisons

Master Booleans and comparisons in programming. Enhance your coding skills with clear examples and practical applications. Perfect for beginners!

Booleans And Comparisons

Explore the differences between null and undefined in JavaScript. Master these concepts to enhance your coding skills and avoid common errors.

Null And Undefined

Explore Bigint and Symbol in JavaScript. Enhance your coding skills with these powerful data types for handling large numbers and unique identifiers.

Bigint And Symbol

Master JavaScript truthy and falsy values with this guide. Enhance coding skills by understanding data types and logical operations.

Truthy Falsy

Break Primitive Types

3. Primitive Types

Master control flow basics in programming. Enhance your coding skills with loops, conditionals, and more. Perfect for beginners!

Intro to Control Flow

Master conditional logic by building a grade calculator that maps numeric scores to letter grades. Sharpen your programming skills today!

Conditionals

Master loops in programming! Enhance your coding skills with efficient loop techniques. Perfect for beginners and pros seeking to optimize code.

Loops

Master nested loops in programming to enhance your coding skills. Discover efficient techniques and practical examples for optimal performance.

Nested Loops

Master the ternary operator for concise code. Discover its syntax, benefits, and examples to enhance your programming skills efficiently.

Ternary Operator

Discover common errors, their causes, and solutions. Enhance your skills by learning to identify and fix mistakes effectively.

Errors

Break Control Flow

4. Control Flow

Master the basics of functions in programming. Enhance your coding skills with clear examples and practical insights. Perfect for beginners!

Programming Foundations

Programming Foundations

Transcript

Switch Statements

Transcript