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

Comparisons

[00:00] So let's get to it. First, I'm going to say, our, loose equals, so const loose equal, loose equal is assigned to a Boolean. So this we actually don't need that. That's the AI. It's just kinda helping us there.

[00:17] But, here's our comparison. We'll talk about billions here in a second. But, here's our comparison. Price is double equal to the quantity. This is going to give us a warning that says this comparison appears to be unintentional because the types number and string have no overlap.

[00:34] Well, let's see. What happens if I remove those types? Well, it still is gonna give me that error because like I said, TypeScript actually is pretty smart and it knows what those types are even without our declarations. But we'll get to that. We'll get to that here in a second.

[00:46] It just bothers me to see those because I never I almost never do this. But, yeah. So TypeScript's pretty smart. It knows that we can't compare those two things. They could not possibly be equal to one another.

[00:57] So this double equal is technically correct. Like, you can technically do this. And what's interesting about this is, what that actually evaluates to, which we'll look at here in a second. I'm gonna add this t s expect error comment right here. What this does is it says, hey, TypeScript.

[01:14] There's an error on the next line. I know and that and it's fine by me. I'm gonna I know better than you, TypeScript. This error, I'm gonna let persist. So, that is kind of the point, of this exercise is to show you that, that error and and everything.

[01:31] But I also want to show you what happens when you do a double equal comparison between a number and a string. So we're gonna leave it there for now and we'll see that here in a second. So then if we do a strict equality, now we're doing three equal signs. We're like, these are really, really equal and we'll see how that differs from the loose equal here once we see the output. So let's console log both of these and I'm gonna just we'll stop here and we'll save it.

[01:56] Now this is very interesting. So loose equality, the double equals, that is true. So price double equals quality but price does not triple equal quality. So what's going on there? Well, in, in JavaScript world, early on, the double equal was I'm not entirely certain why it was done this way.

[02:19] Somebody should ask Brandon at some point. I I probably have a long time ago. I just forgot. But, Brendan Ike is the one who created JavaScript. He's responsible for this funny situation.

[02:31] So, when you're using double equal, it actually does not compare the types between those two things. So it's, it is going to coerce one of those values into the other value just to see if, like, these may not be the same type. They may not be number and number. But can I coerce one of them to be the same? This is basically never something you wanna do.

[02:58] Almost almost never do you ever want to use double equals. It's just probably never what you wanna do. And so triple equals is really the way to go. Yeah. There are, like, some situations when we're talking about this value not equal to null that can also be undefined and stuff.

[03:19] We'll talk about null and undefined later. But even in those situations, I wouldn't even do this. I have other ways to, to handle those situations. So, yeah, pretty much don't ever use double equal. It can be really confusing.

[03:31] Always use triple equal. Alright. Great. So let's continue. We're going to create another variable, not equal loose.

[03:40] So that is a pound or an exclamation point with an equal sign. That's basically the opposite of a double equal and saying it's not equal. And this is a not equal loose. We are not getting a type error here because these are both numbers. And it is perfectly reasonable to use not equals just, with with that, double equal version.

[04:06] But, again, it's just better to use the triple equal version, to avoid weird situations where two variables are of different types. Luckily for us, we don't really have this problem as much anymore anyway because TypeScript helps us kind of avoid some of these issues. But, yeah, that's neither here nor there. Just do the triple equals version. Okay.

[04:28] And then we've got our, greater than symbol, and we also have a less than or equal to. So it's less than or equal to. And don't, don't mix those up, by the way. It's not equal to or greater than. That is actually a function.

[04:43] We'll look at that later. So, the greater than or less than sign appears first and then the equal to. So there's also a oops, const is greater or equal. This is what that would look like. So the greater sign first and then the equal sign.

[05:00] And so that is helpful there and then we'll uncomment this and here we go. We've got our, loose equality, true. And then our strict equality is false. Then, these things are not equal. They're not equal.

[05:13] They're, it's those values are ten and twenty. And then we've got b is greater than a. Yes. B is greater than a. B or a is less than or equal to b.

[05:24] Yes. That is true. And, we could say, let's do 20, And now a is less than or equal to b. Yes. That's true.

[05:31] And now this is false. So we'll look at booleans here in just a little bit too. But, that is comparisons. There's actually a bunch of other operators that you can, you can do here as well that we're not going to get into. They can get more advanced.

[05:45] These are pretty much the most common ones that you're gonna be using, as far as operators go. So there you go. That is comparisons in TypeScript.

[00:00] So now we can do some comparisons. So, we are going to, compare different prices, the quantity. You'll notice this is set to be a string, which is kind of incorrect. And then we've got a couple other numbers down here to do some comparisons between some variables. This is something you're gonna use all the time in your programming in TypeScript, so I'm really excited for you to give this a whirl.

[00:26] I'll just let you have it and we'll

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

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

Comparisons

Transcript