JavaScript development in depth. The important WHY and HOW of critical JavaScript programming.
What you will learn
Critical JavaScript Concepts, Practices and Techniques
Fundamental JavaScript Concepts: Engine, Heap, Call Stack and Event Loop
Object Oriented Programming
Functional Programming
Critical Asynchronous Coding Patterns
All Facets of JavaScript Modules
Error Handling
Critical JavaScript Shortcuts
Execution Context and Lexical Environment
Ubiquitous Nature of Objects
Scope and Block Scope
Type Coercion with Truthy and Falsey
Callbacks
Keyword this
Using call, apply and bind
First Class and Higher Order Functions
Closure
Critical JavaScript Patterns
Immediately Invoked Function Expressions (IIFEs)
Prototype Chain
Constructors, Factory Functions and Classes
Promises and Async Await
Static Method for Asynchronous Patterns
BigInt
Arrow Functions and their Affects on the Keyword this
And Much More
Description
This course focusses on and explains thoroughly the critical concepts and topics found in JavaScript. It dives into important fundaments that often get glossed over. And then takes on the more advanced techniques in JavaScript and explores them deeply. The course not only covers the HOW, it also focusses on the WHY in order to increase your understanding. The HOW and WHY are both critical to becoming a top JavaScript developer.
At 25 hours of instruction, you will master JavaScript in a way only top JavaScript developers do. Here is why:
- The course is taught by the lead trainer at All Things JavaScript, whose mission is to facilitate your journey from novice to expert.
- The course is constantly updated with new content and new topics.
- The course focusses on JavaScript, so you learn JavaScript fully without worrying about ancillary technologies.
- The course explores how things work under the hood so your understanding is deep and relevant.
- The curriculum touches multiple aspects of JavaScript.
- The curriculum was developed over a period of several years.
If you want to improve your JavaScript skills, this course is for you!
The topics you will learn in this course are timeless and will continue to serve you for years in a promising career as a JavaScript developer. You will not find a course as detailed and as in-depth as this course and the concepts and topics taught will put you in the top of all JavaScript developers.
English
language
Content
Introduction
Welcome
How to be Successful in this Course
Getting Set Up
What about Node.js?
Working with Code
Critical JavaScript Concepts
Introduction
The JavaScript Runtime Environment
Understanding the JavaScript Engine
The Memory Heap and Call Stack
Understanding Garbage Collection
Removing Event Listeners
Understanding the Event Loop
The Node Runtime Environment
Exercise Start: Exploring Call Stack and Event Loop
Exercise End: Exploring Call Stack and Event Loop
How JavaScript Evolves
Critical Fundamentals
Section Introduction
The Execution Context
A Consistent Global Object
Hoisting
Function Declarations Versus Function Expressions
Exercise Start: Function Execution Context
Exercise End: Function Execution Context
Lexical Environment
Scope and the Scope Chain
Block Scope
Exercise: Using let in a for Loop
Creating Constants
Should you Continue Using var?
Global Variables and the Danger of the Scope Chain
Exercise Start: Scope
Exercise End: Scope
JavaScript and Data Types
Objects are Everywhere
Type Coercion
Making Use of Truthy and Falsy
Loose Equality Versus Strict Equality
Exercise Start: Coercion
Exercise End: Coercion
Using the BigInt Type
Passing Primitives and Objects: Value or Reference?
Cloning JavaScript Objects
Exercise: Pass by Reference
Exercise Start: Pass by Reference and Cloning
Exercise End: Pass by Reference and Cloning
Using Strict Mode
Tricky Fundamentals
Tricky Fundamentals Introduction
Callbacks
Understanding the Keyword this
Using the Keyword this with Object Methods
Exercise Start: The Keyword this
Exercise End: The Keyword this
Common Issues with the Keyword this
Using call() and apply()
Using bind()
Taking Control of the Keyword this
Exercise Start: Using call(), apply() or bind()
Exercise End: Using call(), apply() or bind()
Arrow Functions
Solving this Binding with Arrow Functions
Arrow Functions are NOT for Every Occasion
Critical Principles and Techniques for Functions
Introduction
Functions are First Class Citizens
Higher Order Functions
Creating Your Own Higher Order Functions
Exercise Start: Create Higher Order Function
Exercise End: Create Higher Order Function
Closures
Using Closure with Returned Functions
Important Features of Closures
Looking Ahead: The Traditional Module Pattern
Exercise Start: Closures 1
Exercise End: Closures 1
Exercise Start: Closures 2
Exercise End: Closures 2
Immediately Invoked Function Expressions (IIFEs)
Applying IIFEs
Exercise Start: IFFEs
Exercise End: IFFEs
Critical Fundamentals for Objects
Introduction
The Nature of Objects
What is a Prototype and Why?
Prototype Objects are Everywhere!
Prototype Chains
Object Properties have Precedence
Programming Paradigms: An Overview
Introduction to Programming Paradigms
Advantages of Programming Paradigms
Object Oriented Programming
Getting Started with OOP
Using Factory Functions to Create Objects
Using Object.create()
Using Prototypes with Factory Functions
Exercise Start: Factory Functions
Exercise End: Factory Functions
Using Constructor Functions for Creating Objects
Prototypal Inheritance with Constructor Functions
Exercise Start: Constructor Functions
Exercise End: Constructor Functions
Gotchas That Could Trip You Up
Using Classes to Create Objects
Exercise Start: Classes
Exercise End: Classes
Using Subclasses
Making Data Private
Parting Thoughts About OOP
Functional Programming
Introduction to Functional Programming
Getting Started with Functional Programming
Advantages of Functional Programming
Using the Spread/Rest Syntax
Exercise Start: Spread/Rest Syntax
Exercise End: Spread/Rest Syntax
Our First Functional Programming Example
Pure Functions
Are Pure Functions Practical?
Exercise Start: Pure Functions
Exercise End: Pure Functions
Understanding Declarative Programming
Using Reduce, Map and Filter
The Importance of Immutability
Currying
Partial Application
Composing Functions
Piping
Understanding Arity and Exercise
Exercise End
Functional Programming Exercise Start
Functional Programming Exercise End
Reviewing Functional Programming
OOP versus FP
Critical Asynchronous Patterns
Introduction to Asynchronous Patterns
Reviewing the Event Loop
What is a Promise?
Using Promises Part 1
Using Promises Part 2 (Fetch API)
What about Fetch in Node?
Exercise Start: Promises
Exercise End: Promises
Creating Promises
Using Static Methods for Multiple Asynchronous Tasks
The async await Pattern
Using async await
Exercise Start: async await
Exercise End: async await
Using Static Methods with async await
Critical JavaScript Shortcuts
Critical JavaScript Shortcuts Introduction
Destructuring Assignment Using Arrays
Destructuring Assignment Using Objects
Short Circuit Evaluation
Nullish Coalescing
Assignment Operator Shortcuts
The Double Bang
Ternary Operator
Optional Chaining for Object Properties
Converting Strings to Numbers
JavaScript Modules
Introduction
What is a Module?
Sample Code Overview
The Traditional Module Pattern
Separating Code Into Modules – Exercise
Exercise Follow Up
Traditional Module Pattern: Linking Modules Together Exercise
Traditional Module Pattern: Linking Exercise Follow Up
CommonJS Modules
CommonJS in Browsers
AMD and UMD Modules
Native Modules
Important Features of Native Modules
Native Modules Exercise – Start
Native Modules Exercise – Follow Up
Bundling the Code Using Webpack
Using ES Modules in Node
Error Handling
Handling JavaScript Errors
Using the try catch Statement
Handling Asynchronous Errors
Using the error Event for Handling Errors
Throwing Errors
Error Handling Strategies
Thank You!
Congratulations!
Appendix 1: JavaScript Basics
Basic JavaScript Introduction
Writing Your First JavaScript Code
Understanding Types and Values
Learning to Manipulate Values
Working with Variables: Part 1
Working with Variables: Part 2
Declaring Variables Using let
Creating Constants
Understanding null and undefined
Working with Operators
Introducing Objects
Working with the Math Object
Working with the Date Object
Using Template Strings
Introducing Loops and Conditionals
Working with the if Conditional Part 1
Working with the if Conditional Part 2
Using Comparison Operators
Working with the While Loop
Using the for Loop
JSON Basics
Creating a JSON File
Appendix 2: Working with the DOM
Introduction to Appendix 2: Working with the DOM
Introducing the DOM
Process for Changing the DOM
Selecting DOM Elements Using Dot Syntax
Selecting DOM Elements by ID, Tag or Class
Selecting DOM Elements Using CSS Classes
Working with Forms
Traversing the DOM
Traversing the DOM in Modern Browsers
Modifying Attributes
Modifying the HTML
BONUS SECTION
BONUS Lecture! Discounts on Other Courses