This course has been updated! We now recommend you take the Deep JavaScript Foundations, v3 course.
Table of Contents
Deep Foundations of Advanced JavaScript v2
Scope
Scopes and Closures Introduction
Kyle reviews the topics that make up the second core foundation of JavaScript: Lexical scope, Nested Scope, Hoisting, Closure
Understanding Scope
Kyle introduces scope as the set of rules for storing variables in some location and for finding those variables at a later time. Kyle then uses the concept of scope to help understand the way the JavaScript compiler works.
Compiling Function Scope
As the JavaScript compiler enters a function, it will begin looking for declaration inside that scope and recursively process them. Once all scopes have been compiled, the execution phase can begin. Kyle also answers questions from students.
Execution of Function Code
As the execution phase continues within the function scope, the same Left-Hand Side (LHS) and Right-Hand Side (RHS) operations are applied. Things get a little interesting with undeclared variables. They are automatically declared in the global scope.
Partner Up for Scope
In this challenge, students pair up with a colleague and explain scoping examples in JavaScript to each other.
Partner Up for Scope Q&A
Kyle answers students' questions from the scoping exericse.
Strict Mode
Kyle recommends using Strict Mode, which is done by putting "use strict" before any other statemnts.
Scope and Execution Example
Kyle walks the audience through another example of how the JavaScript compiler will declare and execute variables and functions. This example includes a nested function which creates a nested scope.
Scope Review
Continuing to help explain Lexical Scope, Kyle quizzes the students.
Named Function Expressions
A function declaration occurs when the function keyword is the first word of the statement. Functions assigned to a variable become function expressions. Kyle explains these difference while also describing the benefits of function expressions. Kyle also answers questions from students.
Lexical Scope
Kyle reviews Lexical Scope and Dynamic Scope, which are two models of scope programming languages.
Function Scoping
Kyle discusses function scoping as a method to use a function to create scope to protect variables from collision or access. To keep the function name from potentially causing a collision, Kyle creates an anonymous function expression.
IIFE Pattern
To create an object in their scope without polluting the outer scope, Kyle demonstrates the Immediately Invoked Function Expressions (IIFE) Pattern, a technique used to hide scope involving wrapping code inside a function that is immediately called. Kyle answers questions from students.
Block Scoping
Kyle reviews the ES6 "let" keyword that will implicitly create a block-level scope and add declarations to that scope rather than the enclosing function. The most common use-case for the let keyword is for loops.
Problems with let Keyword
Kyle describes a few issues he has with the let keyword. Some of his issues are stylistic, but others are related to common variable functionality like hoisting.
Const Keyword
Kyle introduces const, which also creates a block-scoped variable, but whose value is fixed or constant. Any attempt to change that value at a later time results in an error.
Challenge 2: Scoping
Before delivering the next Challenge, Kyle takes a moment to review scope material discussed so far in the course. In this challenge, students take what they have learned about naming function expressions and using block scope and update the simple application code.
Challenge 2: Solution
Kyle walks through the solution to Challenge 2 and takes questions from students.
Hoisting
Kyle explains "hoisting," which is the moving of declarations to the top of the scope block during the compiling phase. Hoisting applies to both variable declarations and functions. Kyle spends some time explaining why hoisting exists in JavaScript and the problems surrounding it.
Challenge 3: Hoisting
In this challenge, students use hoisting to make their code more legible.
Challenge 3: Solution
Kyle walks through the solution to Challenge 3 and takes questions from students.
Closure
Closure Introduction
Kyle introduces closures, which are when a function remembers its lexical scope even when the function is executed outside that lexical scope. Kyle shows examples using some common JavaScript structures like setTimeout and click events. He also demonstrates closure in shared scopes and nested scopes.
Closure Examples
Kyle demonstrates a few additional closure examples inside loops and the misconceptions that arise. He also compares closure to traditional object references to explain the difference.
Challenge 4: Closure
In this challenge, students use closure to expand an entry of text.
Challenge 4: Solution
Kyle walks through the solution to Challenge 4.
Module Patterns
Kyle reviews modules, which let you define private implementation details that are invisible to the outside world. Kyle reviews different module patterns: classic, modern, and ES6 module patterns.
Closure Review
In reviewing Closure, Kyle quizzes the students.
Challenge 5: Module, Part 1
In this challenge, students create module instance with a public API.
Challenge 5: Solution, Part 1
Kyle walks through the solution to Challenge 5, Part 1.
Challenge 5: Module, Part 2
Kyle introduces the second part of the challenge, where students clean up the UI and data operations.
Challenge 5: Solution, Part 2
Kyle walks through the solution to Challenge 5, Part 2 and takes questions from students.
Challenge 5: Module, Part 3
Kyle introduces the third part of the challenge, where students clean up the UI and data operations.
Challenge 5: Solution, Part 3
Kyle walks through the solution to Challenge 5, Part 2 and takes questions from students.
Object-Orienting
Object-Oriented Introduction
Kyle introduces the next core foundation to cover in the course, Object-Orienting: this, Prototypes, class {}, and "Inheritfance" vs. "Behavior Delegation."
this
Kyle reviews the "this" function. Every function, while it's executing, has a reference to its current execution context called "this." The "this" reference is JavaScript's version of dynamic scope. Kyle explains the "this" keyword's relationship to the call site of the function.
Binding Confusion
Kyle demonstrates that attempting to force the "this" keyword into a different lexical scope can lead to some binding confusion.
Explicit Binding
Kyle explains explicit bindings and also detours into a discussion about a technique he calls "hard binding." The explicit binding rule allows developers to use the "call" method and pass an explicit reference for the "this" binding. Explicit bindings can also be set using the "apply" method. Hard binding is available in the form of the "bind" method.
The new Keyword
Kyle explains the functionality of the "new" keyword and the effects it has when placed in front of a function call. JavaScript does not have classes and the "new" keyword does not do any instantiation.
this Review
In reviewing "this," Kyle quizzes the students.
Challenge 6: this
In this challenge, clean up hard-coded lexical references by using what has been learned about "this."
Challenge 6: Solution
Kyle walks through the solution to Challenge 6.
Prototypes
Prototypes Introduction
In JavaScript, every object is built by a constructor function and does not mean classes are being instantiated. When a constructor function is called, a new object is created with a link to the object's prototype.
Explaining Prototypes, Part 1
Using a code example from the slides, Kyle spends some time diagramming the relationship between an object and its prototype.
Explaining Prototypes, Part 2
Kyle explains the relationship between __proto__ (dunder-proto) and the prototype keyword and how both reference the underlining prototype.
Prototype Linkages
Prototype linkages allow delegation to other objects to hand method calls or property references. This process allows additional objects to be created from a prototype with duplication of the function code. This binding is beneficial as long as developers don't break any rules.
Prototype: Objects Linked
Prototypes in JavaScript can be linked and share a parent-child relationship similar to a subclass and superclass. This relationship is beneficial when extending a prototype to add additional methods. However, there are issues with constructor references.
Linked Prototype Diagram
Kyle revisits the prototype diagram he drew on the whiteboard earlier. This time, however, he shows a more sophisticated version outlining the relationship of the two linked prototypes.
Prototype Review
In reviewing Prototype, Kyle quizzes the students.
Challenge 7: Prototype
In this challenge, students convert a module factory function to prototype-style constructor function.
Challenge 7: Solution
Kyle walks through the solution to Challenge 7 and answers students' questions.
ES6 Class
Kyle dives into E6S class, stating that it's "syntactic sugar" and still prototype system.
Class Caution
If you use an ES6 class, Kyle points out the areas of caution.
Clearing Up Inheritance
In classical inheritance, properties and methods of a class are copied to object instantiated from that class. Subclasses inherit the properties and methods of a parent class and copy them to their instantiated objects. Kyle contrasts that with JavaScript's "prototypal inheritance" or "behavior delegation."
Objects Linked as Other Objects
Rather than relating prototypes to inheritance, Kyle demonstrates that prototypes allow actions to be delegated to other objects. Kyle refers to this a Objects Linked to Other Objects (OLOO) and simplifies a coding example by using this OLOO technique. Kyle compares object-oriented (OO), and OLOO approaches.
Delegation: Design Pattern
Kyle discusses the need to change our thinking from the class/inheritance design pattern to the behavior delegation design pattern.
OLOO Review
In further reviewing OLOO, Kyle quizzes the students.
Challenge 8: Convert Modules to Objects
In this challenge, students to take out module design within the small application and convert them into objects.
Challenge 8: Solution
Kyle walks through the solution to Challenge 8 and answers students' questions.
Types
Introducing Types and Coercion
Kyle starts with an overview of first core foundation of JavaScript language: Types and Coercion
Primitive Types Introduction
While reviewing the built-in types: undefined, string, number, boolean, and object, Kyle notes that the symbol "type" is added in ES6 and "function" is a subtype of the "object" type.
Special Values
Kyle discusses special values in primitive types: NaN, Infinity, null, undefined (void), and negative and positive zero (+0, -0).
Negative Zero
Kyle reviews why JavaScript has two zeroes, a normal zero 0, otherwise known as a positive zero or +0, and a negative zero or -0.
Native Functions
Kyle goes over native functions or "natives," which are built-in JavaScript functions and takes questions from students.
Coercion
Abstract Value Operations
Before getting into coercion, Kyle examines the rules that govern how values become either a string, number, or boolean. Then he reviews the abstract operations, or "internal-only operations," ToString, ToNumber, ToBoolean, and ToPrimitive.
Explicit Coercion
Reviewing common coercion operations, Kyle talks about implicit and explicit coercion. Explicit coercion refers to type conversions that are evident for other developers and not leave potential code traps.
Date to number and ~
Kyle discusses Date to number coercion methods including Date.now() static function. He also talks about tilde ~ operator, or otherwise known as "bitwise NOT."
The Bad Parts of Value Coercion
Kyle reviews his thoughts about fixing coercion.
Implicit Coercion: Strings & Numbers
Kyle defines implicit coercion as a side-effect of some other operation or as something that is not clear when looking at the code that coercion will occur. Kyle introduces implicit coercion with a few examples using String and Number values.
Implicit Coercion: Booleans
Kyle reviews the boolean() native function and how booleans behave in JavaScript.
Implicit Coercion: Loose Equals
Mentioning that the most common complaint against implicit coercion in loose equals, == comparisons, comes from how falsy values surprisingly act when compared to each other, Kyle shows that == operator is used for checking values for equality comparison.
Implicit vs Explicit Coercion
Kyle reviews cases for when using double equals when coding.
Double vs. Triple Equal
Kyle discusses that the double-equal operator allows coercion in a comparison while triple equal operator, ===, does not. Afterward, Kyle walks through some examples demonstrating how the result of these two operators can differ.
Double vs. Triple Equal Performance
Kyle explains the performance impacts of double and triple equal operator. Afterward, Kyle shares some pro-tips about how to determine when this operator should be used.
Challenge 1: Coercion
In this challenge, students fix a simple application by checking types and coercion.
Challenge 1: Solution
Kyle walks through the solution to Challenge 1 and takes questions from students.
Wrapping Up Deep Foundations of Advanced JS v2
Case for a Deeper Understanding of JavaScript
Rather than shipping code engineers barely know or use frameworks to aid work at a crutch, Kyle evangelizes for a more thorough understanding of the JavaScript language at a deeper or more deep level can help become better programmers and communicators.
Wrapping Up
Kyle wraps up the Deep Foundations of Advanced JS and gives thanks to the students for their focus and time.