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

Let And Const

[00:00] So let's go ahead and create our tax rate. So we're going to say const tax rate is 0.08. And you'll notice here first, const is a keyword. In my editor, it's showing up as purple. And then we have a space and then followed by the variable name.

[00:18] That space is important by the way. That's I didn't just say that for the fun of it. Then the variable name. Here we have it uppercase tax underscore rate. There is no space between these.

[00:29] You cannot do spaces in variable names. There are a handful of characters that are allowed. Interestingly, dollar is allowed in TypeScript. It's actually kind of interesting. When I started doing JavaScript development, there's a popular library called jQuery, and they had a variable name called dollar, simply just dollar.

[00:50] And you would say dollar, and then you'd do some whatever thing, and now you can do text. Hello, world. Yeah. Whatever. Setting the text of of some element or something.

[00:59] And I was so confused by this dollar thing. Turns out it's just a variable name. So, yes, there are some characters that are allowed to be variable names. Numbers, are not allowed to be variable names unless they're, they are preceded here, so we'd say, preceded by a character. Then you can have numbers in variable names.

[01:20] So, couple interesting rules around that, but that's a basic idea. The other thing that you'll notice is that this is upper case, and and it's got that underscore there. The reason for the underscore is because if you didn't have it, then it would be kind of hard to read long names when it's all upper case like this. The casing actually doesn't matter at all. Most TypeScript developers use camel case and you'll see that here in a second.

[01:46] There's also Pascal case. This is kind of a screaming snake case, I think is what it's called. A bunch of different conventions for casing, but most of the time you're gonna see me using camel case and we'll see what that looks like here in a sec. And then you have a space. That space does not matter.

[02:02] You can actually get rid of that. You can get rid of this one too. The important part here is the equal sign. This is saying assign it to or point it to, this value right here, which we're setting to the number 0.08. So this is less of a reference to an object or something and, which we'll talk about later, and more focused on setting it to a specific value.

[02:26] So there is a part in memory that holds this value. Our variable is pointing to that part in mem that spot in memory, depending on the way that this is implemented. So great. There we go. Let's go ahead and create our cart total.

[02:41] Now the cart total is something that we want to add and subtract and and everything to. So we're going to assign that to let so that we can change that value. Because this is assigned to const and it's assigned to this primitive value, there's nothing that will ever change about this. Now we'll talk about objects and and things, and I'll give you like a little brief primer in objects for, talking about mutation of the value. But the pointer, that cannot change and that's what const means.

[03:10] So let's talk about let. Let allows you to do exactly the same thing. You could even say cart total. There's nothing in JavaScript or TypeScript syntax that says you can't name your variables with the upper case, but convention says that that would be confusing for people who are using your program because typically, upper case means this will never change. But if you use let, then you're communicating, yeah, this actually can and probably will change.

[03:37] So we're gonna say cart total equals zero and then we're going to set all of these values. So the book price, and muffin and laptop price listed with a dollar sign. You do not use dollar signs in TypeScript. Well, you do. I literally just said that you can use that in a variable name.

[03:56] But as far as, like, denoting money or whatever, TypeScript doesn't have any understanding of what that is as far as the syntax is concerned. So you're gonna say book price, muffin price, and laptop price, and you're just gonna set it to this. I suppose this should probably be $4.50. But the zero on the end here is redundant. It's not necessary and even prettier says, oh, let's get rid of that.

[04:20] The formatter says, yeah, this is totally unnecessary. We can get rid of all those. It's the same value anyway. So there we go. We've got our products and now we wanna add the book to the cart.

[04:31] So we're gonna update the cart total. There are a couple ways that you can do this. You'll notice we're using this special operator. This is the plus equals and I'll show you this is exactly the same, equals cart total plus. So these two lines do the same thing, where this is just a little bit more terse.

[04:52] You're basically saying take the cart total and whatever it is, add to it the book price and then assign that value to the cart total again. So it's just a more terse way of doing this longer thing. So we're gonna do it that way. And then we're gonna add the muffin price, to the cart. So the cart total will plus equal the muffin price.

[05:14] And then we'll calculate the final total. We've got Marty the money bag over here helping us in a big way for that, but we want to do a const on the final total because it's final. We're not gonna change it. That's kind of the idea there anyway. And now, I also wanted to have you try to uncomment this.

[05:33] And if your editor is set up with TypeScript, which it probably is if you're using a modern editor, then you're gonna see this error, cannot assign tax rate, because it is a constant. So this is the situation where if we had decided to make this a let, it would work just fine. But const protects us from an unexpected reassigning of the variable. There are some developers out there who say just never use const. Just, except for values just like this.

[06:02] Like, it's never gonna change and and I really wanna make sure it never changes. I I prefer to use const when the value that I or the variable I'm using, is not going to be reassigned to anything, in general. And so that's why we're using const for all of these values even though these aren't like upper case values or anything. I just prefer to use const as a default behavior. Okay.

[06:27] Great. So we're gonna uncomment these all. On my keyboard on Mac, you can do command and then the comment symbol and it will, when you have all those lines selected, and it will uncomment them all. So pro tip. So we get our cart subtotal, our tax, and then the final total.

[06:44] And then here we're going to add this export so that the test can grab those values and we can see them right here. So here we go. We've got our cart subtotal as 20.49000002. Tax is 1.6392000002. What is that all about?

[07:02] That's kinda confusing. And then our final total is like a little bit more reasonable. So this is kind of interesting. An interesting fact about many programming languages is floating point precision. It's a little bit more advanced topic than I want to dive into in this lesson.

[07:20] But basically, you probably shouldn't be using decimals to represent money if you want any sort of precision. When I worked over at PayPal, what we did was, the book price would be $15.99, the number. So 1599¢. And so you're tracking that money in cents. So, just keep that in mind, as you're working with if you ever are working with money in a TypeScript or or actually many other languages program, typically, you're gonna wanna store things in cents, and that way you avoid these precision issues.

[08:01] And in fact, here, let's just try that right here. If we, do that tax rate here, just everything is two decimals over. Save this and, now we avoid the problem and we can say, okay, so the cart subtotal is $16.44. The tax is a lot I think I messed up the tax rate. I think this should still be there we go.

[08:25] So the tax is this and then the final total is that many cents. And it looks like you got half a cent, so now you're going to have to do some math to round up and all of that. But you can avoid that floating point, precision problem. So we're gonna bring that back just for the fun of it. It's kind of fun.

[08:41] People like to joke about the, how JavaScript doesn't do math. JavaScript's not the only one that can't do it. It's just architectural computer things. So, alright. I think that's everything that you need to know so far about variables from this exercise.

[08:56] So awesome job, and we'll see you in the next one.

[00:00] Let's talk about variables. Variables are really foundational for TypeScript and all programming in general. And in this exercise, we are going to have two ways to declare a variable, let and const, where const is a well, actually, both of them are pointers to a value of some kind, whether that be a place in memory that is an object and that's pointers to other things, or a simple singular value of, like, $6 or whatever. So, the, the point is that these are pointers to something, and those pointers can change what they're pointing at if it's a let. If it's const, then that pointer cannot change.

[00:43] And that's what we're going to learn about in this exercise. I'm gonna hand you off to the exercise instructions. Go ahead and work on that, and we'll see you in the solution.

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

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 switch statements in programming. Simplify code logic, enhance readability, and boost efficiency with this essential guide.

Switch Statements

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

Let And Const

Transcript