Пройти курс JavaScript - The Complete Guide 2020 (Beginner + Advanced)

1. Introduction

2. What is JavaScript?

3. JavaScript in Action!

4. Join our Online Learning Community

5. How JavaScript Is Executed

6. Dynamic vs Weakly Typed Languages

7. JavaScript Runs In A Host Environment

8. Course Outline - What Is In The Course?

9. How To Get The Most Out Of This Course

10. Using Course Resources

11. JavaScript vs Java

12. A Brief History Of JavaScript

13. Setting Up a Development Environment

14. Course FAQs

15. Module Introduction

16. Setting Up the Project

17. More on Version Control & Git

18. Adding JavaScript to the Website

19. Introducing Variables & Constants

20. Declaring & Defining Variables

21. Working with Variables & Operators

Тест 1: Variables & Operators

22. Understanding the Starting Code

23. Data Types: Numbers & Strings (Text)

24. Using Constants

25. More on Strings

Тест 2: Data Types & Constants

Задание 1: Time to Practice: Variables, Constants, Operators &

Core Data Types

26. Introducing Functions

27. Adding A Custom Function

28. Code Styles, Conventions & Syntax

29. Returning Values

30. The (Un)Importance of Code Order

31. An Introduction to Global & Local Scope

32. "Shadowed Variables"

33. More about the "return" Statement

34. Executing Functions "Indirectly"

35. "Indirect" vs "Direct" Function Execution - Summary

Тест 3: Functions & Scope

Задание 2: Time to Practice: Functions

36. Converting Data Types

37. Mixing Numbers & Strings

38. Splitting Code into Functions

39. Connecting all Buttons to Functions

40. Working with Code Comments

41. More Operators!

42. More Core Data Types!

43. Using Arrays

44. Creating Objects

45. Objects - Common Syntax Gotchas

46. Accessing Object Data

Тест 4: Arrays & Objects

47. Adding a Re-Usable Function That Uses Objects

48. undefined, null & NaN

49. The "typeof" Operator

Тест 5: "undefined", "null" & "NaN"

50. Importing Scripts Correctly with "defer" & "async"

51. Importing JavaScript - Summary

52. Wrap Up

53. Useful Resources & Links

54. Module Introduction

55. Efficient Development & Debugging - An Overview

56. Configuring the IDE Look & Feel

57. Using Shortcuts

58. Working with Auto-Completion & IDE Hints

59. Installing IDE Extensions

60. Tweaking Editor Settings

61. Utilizing Different IDE Views

62. Finding Help & Working with MDN

63. The ECMAScript Standard

64. How to "google" Correctly

65. Debugging JavaScript - An Overview

66. An Error Message! No Reason To Panic!

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

68. Next-Level Debugging with the Chrome Devtools & Breakpoints

69. Testing Code Changes Directly in the Devtools

70. Debugging Code directly Inside VS Code

71. Wrap Up

72. Useful Resources & Links

73. Module Introduction

74. Introducing "if" Statements & Boolean (Comparison) Operators

75. Using Booleans in Conditions & More on Text Comparisons

76. Using "if" Statements

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

78. Beware When Comparing Objects & Arrays for Equality!

79. The Logical AND and OR Operators

80. Understanding Operator Precedence

Тест 6: if & Boolean Operators - The Basics

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

82. Coercion vs Conversion

Тест 7: Falsy and Truthy Values

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

84. Adding an "Attack" Function

85. Using "if" Statements for Checking the Win-Condition

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

87. Time for a "Heal Player" Functionality!

88. Controlling the Conditional Bonus Life (Without Boolean Operators!)

89. Adding a "Reset Game" Functionality

90. Validating User Input

91. Utilizing Global Constants as Identifiers in Conditional Code

92. Adding a Conditional Battle Log

93. Introducing the Ternary Operator

94. A Bit of Theory: Statements vs Expressions

95. Logical Operator "Tricks" & Shorthands

96. Logical Operators - A Quick Summary

Тест 8: Logical Operators & How They Work

97. Working with the "switch-case" Statement

98. Introducing Loops

99. The "for" Loop

100. The "for-of" Loop

101. The "for-in" Loop

102. The "while" & "do-while" Loops

Тест 9: Loops - Basics

Задание 3: Time to Practice: Control Structures

103. Controlling Loops with "break"

104. Controlling Iterations with "continue"

105. More Control with Labeled Statements

Тест 10: break & continue

106. Error Handling with "try-catch" - An Introduction

107. Throwing Custom Errors

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

Тест 11: Error Handling

109. Wrap Up

110. Useful Resources & Links

111. Module Introduction

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

113. var vs let & const - Introducing "Block Scope"

114. Understanding "Hoisting"

115. Strict Mode & Writing Good Code

Тест 12: "JavaScript Specialties"

116. How Code is Parsed & Compiled

117. Inside the JavaScript Engine - How the Code Executes

118. [DEEP DIVE] JavaScript Language vs Browser APIs

119. Primitive vs Reference Values

120. Garbage Collection & Memory Management

121. Wrap Up

122. Useful Resources & Links

123. Module Introduction

124. Recapping Functions Knowledge - What We Know Thus Far

125. Parameters vs Arguments

126. Functions vs Methods

127. Functions are Objects!

128. Function Expressions: Storing Functions in Variables

129. Function Expressions vs Function Declarations

130. Anonymous Functions

131. Working on the Project: Adding User Choices to the Game

132. Implementing the Core Game Logic

133. Introducing Arrow Functions

134. Different Arrow Function Syntaxes

Тест 13: Creating Functions

135. Outputting Messages to the User

136. Default Arguments in Functions

137. Introducing Rest Parameters ("Rest Operator")

138. Creating Functions Inside of Functions

139. Understanding Callback Functions

Задание 4: Time to Practice: Functions

140. Working with "bind()"

Тест 14: Functions - Advanced

141. Adding bind() to the Calculator Project

142. call() and apply()

143. Wrap Up

144. Useful Resources & Links

145. Module Introduction

146. What's the "DOM"?

147. Document and Window Object

148. Understanding the DOM and how it's created

149. Nodes & Elements - Querying the DOM Overview

150. Selecting Elements in the DOM

151. Summary: Node Query Methods

152. Exploring and Changing DOM Properties

153. Attributes vs Properties

154. Selecting Multiple Elements & Summary

Тест 15: DOM Basics

Задание 5: Time to Practice: DOM Querying

155. Traversing the DOM - Overview

156. Traversing Child Nodes

157. Using parentNode & parentElement

158. Selecting Sibling Elements

159. DOM Traversal vs Query Methods

160. Styling DOM Elements

161. Creating Elements with JS - Overview

162. Adding Elements via HTML in Code

163. Adding Elements via createElement()

164. Inserting DOM Elements

165. Cloning DOM Nodes

166. Live Node Lists vs Static Node Lists

167. Removing Elements

168. Insertion & Removal Method Summary

169. Summary: Insert, Replace, Remove

170. Setting Up the Practice Project

171. Selecting the Modal and "Add" Button

172. Opening a Modal by Changing CSS Classes

173. Controlling the Backdrop

174. Fetching and Validating User Input

175. Creating a Movie in JavaScript & Clearing the Input

176. Rendering Movie Items on the Screen

177. Deleting Movie Elements

178. Showing & Hiding the "Are you sure?" Dialog

179. Starting with the Confirmation Logic

180. Finishing the App

181. Wrap Up

182. Useful Resources & Links

183. Module Introduction

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

185. Creating Arrays

186. Which Data Can You Store In Arrays?

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

188. The splice() Method

189. Selecting Ranges & Creating Copies with slice()

190. Adding Arrays to Arrays with concat()

191. Retrieving Indexes with indexOf() /& lastIndexOf()

192. Finding Stuff: find() and findIndex()

193. Is it Included?

194. Alternative to for Loops: The forEach() Method

195. Transforming Data with map()

196. sort()ing and reverse()ing

197. Filtering Arrays with filter()

198. Where Arrow Functions Shine!

199. The Important reduce() Method

200. Chaining Methods in JavaScript

201. Arrays & Strings - split() and join()

202. The Spread Operator (...)

203. Understanding Array Destructuring

204. Maps & Sets - Overview

205. Working with Sets

206. Working with Maps

207. Maps vs Objects

208. Understanding WeakSet

209. Understanding WeakMap

Задание 6: Time to Practice: Arrays & Iterables

210. Wrap Up

211. Useful Resources & Links

212. Module Introduction

213. What's an Object?

214. Objects & Primitive Values

215. Objects - Recap

216. Adding, Modifying & Deleting Properties

217. Special Key Names & Square Bracket Property Access

218. Property Types & Property Order

219. Dynamic Property Access & Setting Properties Dynamically

Тест 16: Object Properties

220. Demo App & Shorthand Property Syntax

221. Rendering Elements based on Objects

222. for-in Loops & Outputting Dynamic Properties

223. Adding the Filter Functionality

224. Understanding "Chaining" (Property & Method Chaining)

225. The Object Spread Operator (...)

226. Understanding Object.assign()

227. Object Destructuring

228. Checking for Property Existance

229. Introducing "this"

230. The Method Shorthand Syntax

231. The "this" Keyword And Its Strange Behavior

232. call() and apply()

233. What the Browser (Sometimes) Does to "this"

234. "this" and Arrow Functions

235. "this" - Summary

Тест 17: "this"

236. Getters & Setters

237. Wrap Up

238. Useful Resources & Links

239. Module Introduction

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

241. Getting Started with OOP Code

242. Defining & Using a First Class

243. Working with Constructor Methods

244. Fields vs Properties

245. Using & "Connecting" Multiple Classes

246. Binding Class Methods & Working with "this"

247. Adding a Cart and Shop Class

248. Communicating Can Be Challenging!

249. Static Methods & Properties

250. First Summary & Classes vs Object Literals

251. Getters & Setters

252. Introducing Inheritance

253. Implementing Inheritance

254. Using Inheritance Everywhere

255. Overriding Methods and the super() Constructor

256. super() Constructor Execution, Order & "this"

257. Different Ways of Adding Methods

258. Private Properties

259. "Pseudo-Private" Properties

Задание 7: Time to Practice: Classes & OOP

260. The "instanceof" Operator

261. Built-in Classes

262. Understanding Object Descriptors

Тест 18: Classes

263. Wrap Up

264. Useful Resources & Links