JavaScript - The Tricky Parts

JavaScript is amazing but it has some "quirks and features". In this course, we'll dive into 'this', closures, recursion, hoisting, scopes and much, much more!

Start

JavaScript is an amazing programming language - and a very versatile one, too.

But it also can be tricky at times.

There are some concepts in JavaScript, that often lead to confusion and errors - that's exactly what we'll dive into in this course!

This course will explore the following "tricky parts" in depth AND in understandable words, so that you can use this course both as a reference you come back to in the future as well as a resource to strengthen your JavaScript knowledge:

  • Scope & Hoisting
  • Callback Functions (Indirect vs Direct Function Execution)
  • Loops (yes, they do contain some "weird" parts)
  • Primitive vs Reference Values
  • Value Types & Type Coercion
  • Recursion
  • Closures
  • Asynchronous Code (Callbacks, Promises, async/ await)
  • The "this" Keyword
  • Prototypes

Those concepts will be explained in detail and theory as well as in practice with short and concise code snippets and examples.

You will learn:-

  • What's tricky about those concepts
  • WHY it works the way it works
  • WHAT you should remember or keep in mind

Important: This course is NOT a course for beginners! JavaScript knowledge is expected!

But you don't have to be an expert or advanced user.

This course aims to help you understand those tricky concepts, it's also meant to be a resource you can dive into if you just want to look up one specific concept (instead of having to search through an entire JavaScript course).

Therefore, every course section is built such that it works standalone, independent from the other sections. There is no overarching course project or anything like that - instead, you get "to the point", focused sections that have the goal of making those "tricky parts" less tricky as quickly as possible!

Section: Getting Started

1. Welcome to the Course! (1:53) Preview
2. About this Course (5:14) Preview
3. Course Requirements & Info (1:39) Preview
4. How To Take This Course (2:05) Preview
5. Join the Learning Community (1:00)

Section: Scopes & Hoisting

6. Module Introduction (0:30) Preview
7. Getting Started (2:39) Preview
8. Scope in Theory (2:31) Preview
9. Introducing Global and Local (Function) Scope (4:07) Preview
10. How Scope Works (4:47) Preview
11. Getting to Know "Block Scope" (7:56) Preview
12. Scope Overview (1:44) Preview
13. Special Cases (11:02) Preview
14. The Global Object (7:11) Preview
15. Scope Across Files (4:13) Preview
16. Modules & Scope (7:53) Preview
17. Variable Shadowing (3:54) Preview
18. Quiz: Scope (1:00) Preview
19. What is "Hoisting"? (4:00)
20. Hoisting in Action (7:32)
21. Hoisting Inside Of Functions (3:05)
22. "let" & "const" and Hoisting (5:57)
23. Hoisting Precedence (3:12)
24. Quiz: Hoisting (1:00)
25. Module Resources (1:00)

Section: Direct vs Indirect Function Execution (Callbacks & Events)

26. Module Introduction (0:34)
27. Direct vs Indirect Function Execution (2:38)
28. Direct Execution in Action (3:30)
29. Indirect Execution in Action (4:53)
30. Indirect Execution With Anonymous Functions (2:24)
31. Indirect Execution and Passing Arguments (7:49)
32. Quiz: Direct vs Indirect Function Execution (1:00)
33. Module Resources (1:00)

Section: Loops

34. Module Introduction (0:21)
35. Loops Overview (3:23)
36. The "for" Loop (6:09)
37. The "for" Loop with "let" (2:46)
38. The "for ... in ..." Loop (7:04)
39. The "for ... of ..." Loop (5:09)
40. Using forEach() (4:04)
41. Quiz: Loops (1:00)
42. Module Resources (1:00)

Section: Primitive vs Reference Values

43. Module Introduction (0:39)
44. What are "Primitive" and "Reference Values"? (7:03)
45. Primitive Values in Action (6:27)
46. Reference Values in Action (3:00)
47. Behind the Scenes (2:32)
48. Immutability vs Mutability (2:35)
49. Primitive Wrapper Objects (4:37)
50. "const" & Mutation (5:32)
51. Reference Value Equality (6:06)
52. Copying Reference Values (13:01)
53. Quiz: Primitive vs Reference Values (1:00)
54. Module Resources (1:00)

Section: Types & Type Coercion

55. Module Introduction (0:45)
56. What's Special About Types in JavaScript? (3:17)
57. What is "Coercion"? (5:48)
58. How Operators Influence Types & Coercion (6:14)
59. Coercion Rules (9:38)
60. Arithmetic Operators & Basic Comparisons (7:29)
61. Comparison Operators for Booleans & Coercion (5:59)
62. Truthy and Falsy Values (4:58)
63. Boolean Return Values (4:45)
64. Explicit Boolean Coercion with the Double Bang Operator (3:46)
65. Semi-explicit Value Coercion (2:57)
66. The Special Case of "null" (7:18)
67. More on null, undefined and NaN (4:10)
68. Objects & Arrays - Coercion Theory (3:41)
69. Objects & Arrays - Coercion in Action (5:18)
70. Objects & Comparisons (6:12)
71. Explicit Object Coercion (4:08)
72. Implicit Number Coercion for Objects (2:33)
73. Wrap Up (1:47)
74. Quiz & Time to Practice (16:29)
75. Module Resources (1:00)

Section: Recursion

76. Module Introduction (0:47)
77. What is "Recursion"? (8:36)
78. A Look Under The Hood (11:45)
79. Analyzing Recursion with the Browser DevTools (7:28)
80. Where Recursion Shines (20:52)
81. Quiz: Recursion (1:00)
82. Module Resources (1:00)

Section: Closures

83. Module Introduction (0:47)
84. Closures in Theory (4:15)
85. Closures in Practice (2:27)
86. Multiple Environments & Closures (3:22)
87. How Closures Actually Work (5:39)
88. A Special Case (9:37)
89. Quiz: Closures (1:00)
90. Module Resources (1:00)

Section: Asynchronous Code

91. Module Introduction (0:38)
92. What is "Async Code"? (5:24)
93. JavaScript is Single-Threaded! (4:17)
94. Callbacks (8:05)
95. Another Callback Example (2:50)
96. Promises (5:35)
97. Promises in Action (11:14)
98. Behind the Scenes of Promises (8:04)
99. Working with "then()" (5:06)
100. Promisifying APIs (3:24)
101. Handling Errors (10:16)
102. Using "catch()" (2:59)
103. Rejecting Promises - Behind the Scenes (3:19)
104. Using async/ await (8:20)
105. Quiz: Async Code (1:00)
106. Module Resources (1:00)

Section: The "this" Keyword

107. Module Introduction (0:43)
108. What is "this" about? (6:14)
109. "this" in Action (3:27)
110. How "this" works (4:16)
111. Special & Tricky Cases (10:02)
112. "Fixing" "this": Helper Variables & bind() (5:48)
113. Working with Arrow Functions (4:22)
114. Quiz: "this" (1:00)
115. Module Resources (1:00)

Section: Prototypes & Inheritance

116. Module Introduction (0:41)
117. JavaScript Objects - Refresher (incl. Constructor Functions) (11:19)
118. What are "Prototypes" in JavaScript? (9:43)
119. Understanding Prototypes (5:49)
120. The Prototype Chain (3:15)
121. Setting & Changing Prototypes (3:46)
122. Pre-defining the Prototype on Constructor Functions (6:02)
123. Changing Prototypes (Patching) (6:37)
124. The Default Prototype and "Monkey Patching" (4:18)
125. Prototypes & "this" (2:51)
126. Protoypes, Classes & Methods (9:32)
127. Prototypes and the "constructor" Property (Method) (2:24)
128. Quiz: Prototypes (1:00)
129. Module Resources (1:00)

Course Instructor

Image

Maximilian Schwarzmüller

As a self-taught professional I really know the hard parts and the difficult topics when learning new or improving on already-known languages. This background and experience enable me to focus on the most relevant key concepts and topics. My track record of many 5-star rated courses, more than 1,000,000 students worldwide as well as a successful YouTube channel is the best proof for that.

The most rewarding experience for me is to see how people find new, better jobs, build awesome web applications, work on amazing projects or simply enjoy their hobby with the help of my content. That's why, together with Manuel Lorenz, I founded Academind to offer the best possible learning experience and to share the pleasure of learning with our students.