English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 180 lectures (19h 0m) | 6.71 GB
Level Up Your JS. Covers latest syntax, design patterns, functional programming, browser APIS, OOP, Canvas, and more!
Transform your basic JavaScript knowledge into expert-level skills with this brand-new comprehensive course designed for those ready to take the next big leap in their programming career. If you’ve ever found yourself intimidated by JavaScript’s more complex features or struggled to grasp its intricate concepts, this course is tailor-made for you. If you’ve taken a few Udemy courses on JavaScript and don’t know where to go next, this course is for you!
This course demystifies the ‘scary’ and tricky parts of JavaScript, guiding you through the intricate details and advanced aspects with ease. By the end of this journey, you’ll not only understand these concepts but also skillfully apply them in real-world scenarios.
Key Topics Covered:
- Object-Oriented Programming (OOP): SOLID design principles, prototypes, private class fields, etc.
- JavaScript Design Patterns: Proxy objects, module pattern, singleton pattern, observer pattern, mixin pattern, registry pattern, and others.
- Advanced JavaScript APIs: IndexedDB, Geolocation, Web Sockets, Notifications API, Canvas, getUserMedia, and more.
- ‘this’ Keyword Mastery: Deep dive into ‘this’, call, apply, and bind methods.
- Asynchronous Programming: Master promises, async/await, asynchronous design patterns, and write your own promise objects
- Modern JavaScript Features: Optional chaining, nullish coalescing, logical assignment operators, and other ES2021 & ES2022 features
- Tricky Parts of JavaScript: Tackle closures, float imprecision, BigInt, automatic semicolon insertion and a bunch more.
- Functional Programming Techniques: Recursion, currying, composition, partial application, and more.
Whether you’re a self-taught programmer, a computer science student, or a professional developer looking to sharpen your JavaScript skills, this course will elevate your coding abilities, preparing you to handle advanced web development challenges with confidence and expertise.
What you’ll learn
- Explore Advanced JavaScript Patterns and Practices: proxy objects, observers, generators, and more
- Apply Advanced Functional Programming Techniques: currying, composition, and more
- Understand Scope, Closures, and Hoisting
- Work with JavaScript APIs including Intersection Observers, Canvas, Web Sockets, and more
- Master the trickiest parts of JavaScript
- Learn the latest ES2021 & ES2022 features
Table of Contents
Introduction
1 Course Welcome & Introduction
2 Curriculum Walkthrough
3 Getting The Course Code
4 My Developer Environment
Object Oriented JavaScript
5 Working With Plain Old JavaScript Objects
6 Mixing Data & Functions With Objects
7 Class Basics
8 Constructors
9 Practice Time Bank Account
10 Instance Methods
11 Inheritance Basics
12 The Super Keyword
13 Static Properties
14 Static Methods
15 Use Cases For Static Methods
16 Ebook Exercise
17 ArrayUtils exercise
18 Getters and Setters exercise
19 Connect Four OO Exercise
OOP Newer Features in JavaScript
20 Getters
21 Setters
22 Practice Time Getters and Setters
23 Public Fields
24 Private Fields
25 Private Methods
26 ES2022 Static Initialization Blocks
The Mysterious Keyword This
27 Introducing This
28 The Mystery of The Keyword This
29 Global Objects and This
30 The Left Of The Dot Rule
31 This and Classes
32 The Call Method
33 The Apply Method
34 The Bind Method
35 Binding Arguments
36 Bind With Event Listeners
37 Bind With Timers
38 Arrow Functions and This
39 This Takeaways
40 Buggy Code `this` Exercise
41 Buggy Code `this` Timers Exercise
OOP Under The Hood Prototypes, New, & More!
42 OOP Under The Hood Intro
43 The New Keyword
44 Prototypes Part 1
45 Prototypes Part 2
46 Prototypes Part 3
47 The Prototype Chain
48 Classes, Inheritance, & Prototypes
49 proto__ vs. prototype
50 Useful Prototype Methods
Asynchronous Code
51 Callbacks Our Good Friend
52 Callback Hell & The Pyramid of Doom
53 The Basics of Promises
54 Using .then() and .catch()
55 Promise Chaining To Flatten Code
56 Error Handling With Promises
57 AsyncAwait Basics
58 More on AsyncAwait
59 Error Handling With Async Functions
60 Async Patterns Parallel Async Operations
61 Async Patterns Sequential Async Operations
62 Async Patterns Promise.all()
63 Async Patterns Promise.allSettled()
64 Async Patterns Promise.race()
65 Building Our Own Promise Objects
66 Promisifying Node’s fs.readFile()
67 Async Num Cards Exercise
Latest JavaScript Features
68 Optional Chaining
69 Nullish Coalescing
70 Numeric Separators
71 Array.prototype.at()
72 String replaceAll()
73 Logical OR Assignment =
74 Logical AND Assignment &&=
75 Nullish Coalescing Assignment =
76 Promise.any()
77 New OOP Features Private Fields & Static Initialization Blocks
The Tricky Parts of JavaScript
78 Working With Float Imprecision
79 BigInt() and Really Large Numbers
80 isNan() vs. Number.isNaN()
81 Post and Pre Increment ++x vs. x++
82 Automatic Semicolon Insertion
83 JavaScript Generator Functions
84 When Are Generators Useful
85 The Incredibly Versatile Array.from() Method
86 parseAndCheck Exercise
87 Prefix and Postfix Exercise
88 rangeGenerator Exercise
The Tricky Parts Scope & Closures
89 Recaping Var & Scope
90 Recaping Let, Const, & Scope
91 The Scope Chain
92 Static Scope
93 Hoisting
94 IIFEs
95 Closures The Basics
96 Closures Another Example
97 Closures Factory Functions
98 Closures Event Listeners
99 Closures Loops
100 Guessing Game Exercise
101 Bank Account Exercise
102 Special Add Exercise
Timers Debouncing, Throttling, & RequestAnimationFrame
103 setTimeout
104 setInterval
105 clearInterval
106 clearTimeout
107 Debouncing
108 Writing a Fancy Debounce Function
109 Throttling
110 Building a Fancy Throttle Function
111 requestAnimationFrame Basics
112 requestAnimationFrame With Timestamps
113 Scroll To Top Animation With RequestAnimationFrame
Functional Programming
114 Introducing Functional Programming
115 First Class Functions
116 Writing Pure Functions
117 Returning Functions
118 Immutability
119 Recursion
120 Partial Application With Bind
121 Writing a Partial Function
122 Composition Basics
123 A Simple Compose Function
124 Writing a Fancier Compose Function
125 Currying Basics
126 More Advanced Currying
127 Dice Game Intro
128 Dice Game Simple FP
129 Dice Game Going Overboard with FP
130 Functional Programming Wrapup
131 Flip Exercise
132 FP Stylizer Exercise
Fetch API
133 The Basics of Fetch
134 Error Handling With Fetch
135 Sending Request Headers With Fetch
136 POST Requests With Fetch
137 Uploading Files With Fetch
138 JSON Placeholder Exercise
Web Storage APIs
139 LocalStorage Basics
140 LocalStorage With Complex Objects
141 What Should & Should Not Go In LocalStorage
142 Creating a Darkmode Toggle With LocalStorage
143 Localstorage Notes App Demo
144 Syncing Tabs With The Storage Event
145 SessionStorage Basics
146 Session Storage Form Demo
147 IndexedDB Enter At Your Own Risk!
Browser APIs Geolocation, Intersection Observers, and More!
148 Using the Geolocation API
149 The getUserMedia API
150 Intersection Observers Basics
151 Intersection Observers Thresholds
152 Intersection Observers Tracking Ad View Time
153 Intersection Observers Multiple Entries
154 Intersection Observers Lazy Loading Images
Performance API & Web Audio
155 Performance API Basics
156 Measuring Resource Load Times With Performance API
157 The Web Audio API Basics
158 Web Audio Theremin Slider Demo
159 Web Audio API Use Cases
Canvas API
160 Intro To The Canvas API
161 Canvas Basics
162 Canvas Strokes and Lines
163 Canvas Arcs and Paths
164 Other Canvas Features
165 Building A Bouncing Balls Toy Pt 1
166 Building A Bouncing Balls Demo Pt 2
167 Building A Bouncing Balls Demo Pt 3
Web Sockets API
168 Introducing Web Sockets
169 Basics Of The Web Sockets API
170 Web Socket Events
171 Building A Chat App With Web Sockets Pt 1
172 Building A Chat App With Web Sockets Pt 2
173 Building A Chat App With Web Sockets Pt 3
Notifications API
174 Sending Notifications
175 Notification Events
176 Notifications With Icons and Data
177 Adding Notifications To Our Chat App Pt. 1
178 Adding Notifications To Our Chat App Pt. 2
SOLID OOP Principles
179 Single Responsibility Principle
180 OpenClosed Principle
181 Liskov Substitution Principle
182 Interface Segregation Principle
183 Dependency Inversion Principle
184 Law Of Demeter
Design Patterns & Proxy Objects
185 Module Pattern
186 Singleton Pattern
187 Observer Pattern
188 Registry Pattern
189 Mixin Pattern
190 Proxy Pattern With Proxy Objects
191 Proxying Function Calls
192 Implementing Data Binding With Proxy Objects
Resolve the captcha to access the links!