JavaScript - The Complete Guide (Beginner + Advanced) 

Introduction

What is JavaScript?

JavaScript in Action!

Join our Online Learning Community

How JavaScript Is Executed

Dynamic vs Weakly Typed Languages

JavaScript Runs In A Host Environment

Course Outline - What Is In The Course?

How To Get The Most Out Of This Course

Using Course Resources

JavaScript vs Java

A Brief History Of JavaScript

Setting Up a Development Environment

Course FAQs

Module Introduction

Setting Up the Project

More on Version Control & Git

Adding JavaScript to the Website

Introducing Variables & Constants

Declaring & Defining Variables

Working with Variables & Operators

Understanding the Starting Code

Data Types: Numbers & Strings (Text)

Using Constants

More on Strings

Introducing Functions

Adding A Custom Function

Code Styles, Conventions & Syntax

Returning Values

The (Un)Importance of Code Order

An Introduction to Global & Local Scope

"Shadowed Variables"

More about the "return" Statement

Executing Functions "Indirectly"

"Indirect" vs "Direct" Function Execution - Summary

Converting Data Types

Mixing Numbers & Strings

Splitting Code into Functions

Connecting all Buttons to Functions

Working with Code Comments

More Operators!

More Core Data Types!

Using Arrays

Creating Objects

Objects - Common Syntax Gotchas

Accessing Object Data

Adding a Re-Usable Function That Uses Objects

undefined, null & NaN

The "typeof" Operator

Importing Scripts Correctly with "defer" & "async"

Importing JavaScript - Summary

Wrap Up

Useful Resources & Links

Module Introduction

Efficient Development & Debugging - An Overview

Configuring the IDE Look & Feel

Using Shortcuts

Working with Auto-Completion & IDE Hints

Installing IDE Extensions

Tweaking Editor Settings

Utilizing Different IDE Views

Finding Help & Working with MDN

The ECMAScript Standard

How to "google" Correctly

Debugging JavaScript - An Overview

An Error Message! No Reason To Panic!

Using console.log() to look "into the Code"

Next-Level Debugging with the Chrome Devtools & Breakpoints

Testing Code Changes Directly in the Devtools

Debugging Code directly Inside VS Code

Debugging Code directly Inside VS Code

Wrap Up

Useful Resources & Links

Module Introduction

Introducing "if" Statements & Boolean (Comparison) Operators

Using Booleans in Conditions & More on Text Comparisons

Using "if" Statements

Working with "if", "else" and "else-if"

Beware When Comparing Objects & Arrays for Equality!

The Logical AND and OR Operators

Understanding Operator Precedence

Beyond true/ false: "Truthy" and "Falsy" Values

Coercion vs Conversion

Setting Up a Bigger Example Project (The "Monster Killer")

Adding an "Attack" Function

Using "if" Statements for Checking the Win-Condition

Adding More "if" Statements & A "Strong Attack" Functionality

Time for a "Heal Player" Functionality!

Controlling the Conditional Bonus Life (Without Boolean Operators!)

Adding a "Reset Game" Functionality

Validating User Input

Utilizing Global Constants as Identifiers in Conditional Code

Adding a Conditional Battle Log

Introducing the Ternary Operator

A Bit of Theory: Statements vs Expressions

Logical Operator "Tricks" & Shorthands

Logical Operators - A Quick Summary

Working with the "switch-case" Statement

Introducing Loops

The "for" Loop

The "for-of" Loop

The "for-in" Loop

The "while" & "do-while" Loops

Controlling Loops with "break"

Controlling Iterations with "continue"

More Control with Labeled Statements

Error Handling with "try-catch" - An Introduction

Throwing Custom Errors

Working with "try-catch" to Catch & Handle Errors

Wrap Up

Useful Resources & Links

Module Introduction

ES5 vs ES6+ ("Next Gen JS") - Evolution of JavaScript

var vs let & const - Introducing "Block Scope"

Understanding "Hoisting"

Strict Mode & Writing Good Code

How Code is Parsed & Compiled

Inside the JavaScript Engine - How the Code Executes

[DEEP DIVE] JavaScript Language vs Browser APIs

Primitive vs Reference Values

Garbage Collection & Memory Management

Wrap Up

Useful Resources & Links

Module Introduction

Recapping Functions Knowledge - What We Know Thus Far

Parameters vs Arguments

Functions vs Methods

Functions are Objects!

Function Expressions: Storing Functions in Variables

Function Expressions vs Function Declarations

Anonymous Functions

Working on the Project: Adding User Choices to the Game

Implementing the Core Game Logic

Introducing Arrow Functions

Different Arrow Function Syntaxes

Outputting Messages to the User

Default Arguments in Functions

Introducing Rest Parameters ("Rest Operator")

Creating Functions Inside of Functions

Understanding Callback Functions

Working with "bind()"

Adding bind() to the Calculator Project

call() and apply()

Wrap Up

Useful Resources & Links

Module Introduction

What's the "DOM"?

Document and Window Object

Understanding the DOM and how it's created

Nodes & Elements - Querying the DOM Overview

Selecting Elements in the DOM

Summary: Node Query Methods

Exploring and Changing DOM Properties

Attributes vs Properties

Selecting Multiple Elements & Summary

Traversing the DOM - Overview

Traversing Child Nodes

Using parentNode & parentElement

Selecting Sibling Elements

DOM Traversal vs Query Methods

Styling DOM Elements

Creating Elements with JS - Overview

Adding Elements via HTML in Code

Adding Elements via createElement()

Inserting DOM Elements

Cloning DOM Nodes

Live Node Lists vs Static Node Lists

Removing Elements

Insertion & Removal Method Summary

Summary: Insert, Replace, Remove

Setting Up the Practice Project

Selecting the Modal and "Add" Button

Opening a Modal by Changing CSS Classes

Controlling the Backdrop

Fetching and Validating User Input

Creating a Movie in JavaScript & Clearing the Input

Rendering Movie Items on the Screen

Deleting Movie Elements

Showing & Hiding the "Are you sure?" Dialog

Starting with the Confirmation Logic

Finishing the App

Wrap Up

Useful Resources & Links

Module Introduction

What are "Iterables" and "Array-like Objects"?

Creating Arrays

Which Data Can You Store In Arrays?

push(), pop(), unshift(), shift() - Adding & Removing Elements

The splice() Method

Selecting Ranges & Creating Copies with slice()

Adding Arrays to Arrays with concat()

Retrieving Indexes with indexOf() /& lastIndexOf()

Finding Stuff: find() and findIndex()

Is it Included?

Alternative to for Loops: The forEach() Method

Transforming Data with map()

sort()ing and reverse()ing

Filtering Arrays with filter()

Where Arrow Functions Shine!

The Important reduce() Method

Chaining Methods in JavaScript

Arrays & Strings - split() and join()

The Spread Operator (...)

Understanding Array Destructuring

Maps & Sets - Overview

Working with Sets

Working with Maps

Maps vs Objects

Understanding WeakSet

Understanding WeakMap

Wrap Up

Useful Resources & Links

Module Introduction

What's an Object?

Objects & Primitive Values

Objects - Recap

Adding, Modifying & Deleting Properties

Special Key Names & Square Bracket Property Access

Property Types & Property Order

Dynamic Property Access & Setting Properties Dynamically

Demo App & Shorthand Property Syntax

Rendering Elements based on Objects

for-in Loops & Outputting Dynamic Properties

Adding the Filter Functionality

Understanding "Chaining" (Property & Method Chaining)

The Object Spread Operator (...)

Understanding Object.assign()

Object Destructuring

Checking for Property Existance

Introducing "this"

The Method Shorthand Syntax

The "this" Keyword And Its Strange Behavior

call() and apply()

What the Browser (Sometimes) Does to "this"

"this" and Arrow Functions

"this" - Summary

Getters & Setters

Wrap Up

Useful Resources & Links

Module Introduction

What is "Object-oriented Programming" (OOP)?

Getting Started with OOP Code

Defining & Using a First Class

Working with Constructor Methods

Fields vs Properties

Using & "Connecting" Multiple Classes

Binding Class Methods & Working with "this"

Adding a Cart and Shop Class

Communicating Can Be Challenging!

Static Methods & Properties

First Summary & Classes vs Object Literals

Getters & Setters

Introducing Inheritance

Implementing Inheritance

Using Inheritance Everywhere

Overriding Methods and the super() Constructor

super() Constructor Execution, Order & "this"

Different Ways of Adding Methods

Private Properties

"Pseudo-Private" Properties

The "instanceof" Operator

Built-in Classes

Understanding Object Descriptors

Wrap Up

Useful Resources & Links

Module Introduction

Introducing Constructor Functions

Constructor Functions vs Classes & Understanding "new"

Introducing Prototypes

Prototypes - Summary

Working with Prototypes

The Prototype Chain and the Global "Object"

Classes & Prototypes

Methods in Classes & In Constructors

Built-in Prototypes in JavaScript

Setting & Getting Prototypes

Wrap Up

Useful Resources & Links

Module Introduction

First Project Steps & Planning

Creating Project Lists & Parsing Element Data

Starting with the "Switch Project" Logic

Passing Method References Around

Moving DOM Elements

Adding a Tooltip

Adding Inheritance

Wrap Up

Useful Resources & Links

Module Introduction

Using "dataset" (data-* Attributes)

Getting Element Box Dimensions

Working with Element Sizes & Positions

The DOM & Prototypes

Positioning the Tooltip

Handling Scrolling

Working with