|
|
01. Introduction
|
|
01. Introduction
|
|
|
02. What is JavaScript
|
|
|
03. JavaScript in Action!
|
|
|
04. Join our Online Learning Community
|
|
|
05. How JavaScript Is Executed
|
|
|
06. Dynamic vs Weakly Typed Languages
|
|
|
07. JavaScript Runs In A Host Environment
|
|
|
08. Course Outline - What Is In The Course
|
|
|
09. 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
|
|
|
|
02. Basics Variables, Data Types, Operators & Functions
|
|
01. Module Introduction
|
|
|
02. Setting Up the Project
|
|
|
03. More on Version Control & Git
|
|
|
04. Adding JavaScript to the Website
|
|
|
05. Introducing Variables & Constants
|
|
|
06. Declaring & Defining Variables
|
|
|
07. Working with Variables & Operators
|
|
|
08. Variables & Operators
|
|
|
09. Understanding the Starting Code
|
|
|
10. Data Types Numbers & Strings (Text)
|
|
|
11. Using Constants
|
|
|
12. More on Strings
|
|
|
13. Data Types & Constants
|
|
|
14. Time to Practice Variables, Constants, Operators & Core Data Types
|
|
|
15. Introducing Functions
|
|
|
16. Adding A Custom Function
|
|
|
17. Code Styles, Conventions & Syntax
|
|
|
18. Returning Values
|
|
|
19. The (Un)Importance of Code Order
|
|
|
20. An Introduction to Global & Local Scope
|
|
|
21. Shadowed Variables
|
|
|
22. More about the return Statement
|
|
|
23. Executing Functions Indirectly
|
|
|
24. Indirect vs Direct Function Execution - Summary
|
|
|
25. Functions & Scope
|
|
|
26. Time to Practice Functions
|
|
|
27. Converting Data Types
|
|
|
28. Mixing Numbers & Strings
|
|
|
29. Splitting Code into Functions
|
|
|
30. Connecting all Buttons to Functions
|
|
|
31. Working with Code Comments
|
|
|
32. More Operators!
|
|
|
33. More Core Data Types!
|
|
|
34. Using Arrays
|
|
|
35. Creating Objects
|
|
|
36. Objects - Common Syntax Gotchas
|
|
|
37. Accessing Object Data
|
|
|
38. Arrays & Objects
|
|
|
39. Adding a Re-Usable Function That Uses Objects
|
|
|
40. undefined, null & NaN
|
|
|
41. The typeof Operator
|
|
|
42. undefined, null & NaN
|
|
|
43. Importing Scripts Correctly with defer & async
|
|
|
44. Importing JavaScript - Summary
|
|
|
45. Wrap Up
|
|
|
46. Useful Resources & Links
|
|
|
|
03. Efficient Development & Debugging
|
|
01. Module Introduction
|
|
|
02. Efficient Development & Debugging - An Overview
|
|
|
03. Configuring the IDE Look & Feel
|
|
|
04. Using Shortcuts
|
|
|
05. Working with Auto-Completion & IDE Hints
|
|
|
06. Installing IDE Extensions
|
|
|
07. Tweaking Editor Settings
|
|
|
08. Utilizing Different IDE Views
|
|
|
09. Finding Help & Working with MDN
|
|
|
10. The ECMAScript Standard
|
|
|
11. How to google Correctly
|
|
|
12. Debugging JavaScript - An Overview
|
|
|
13. An Error Message! No Reason To Panic!
|
|
|
14. Using console.log() to look into the Code
|
|
|
15. Next-Level Debugging with the Chrome Devtools & Breakpoints
|
|
|
16. Testing Code Changes Directly in the Devtools
|
|
|
17. Debugging Code directly Inside VS Code
|
|
|
18. Wrap Up
|
|
|
19. Useful Resources & Links
|
|
|
|
04. Working with Control Structures (if Statements, Loops, Error Handling)
|
|
01. Module Introduction
|
|
|
02. Introducing if Statements & Boolean (Comparison) Operators
|
|
|
03. Using Booleans in Conditions & More on Text Comparisons
|
|
|
04. Using if Statements
|
|
|
05. Working with if, else and else-if
|
|
|
06. Beware When Comparing Objects & Arrays for Equality!
|
|
|
07. The Logical AND and OR Operators
|
|
|
08. Understanding Operator Precedence
|
|
|
09. if & Boolean Operators - The Basics
|
|
|
10. Beyond true false Truthy and Falsy Values
|
|
|
11. Coercion vs Conversion
|
|
|
12. Falsy and Truthy Values
|
|
|
13. Setting Up a Bigger Example Project (The Monster Killer)
|
|
|
14. Adding an Attack Function
|
|
|
15. Using if Statements for Checking the Win-Condition
|
|
|
16. Adding More if Statements & A Strong Attack Functionality
|
|
|
17. Time for a Heal Player Functionality!
|
|
|
18. Controlling the Conditional Bonus Life (Without Boolean Operators!)
|
|
|
19. Adding a Reset Game Functionality
|
|
|
20. Validating User Input
|
|
|
21. Utilizing Global Constants as Identifiers in Conditional Code
|
|
|
22. Adding a Conditional Battle Log
|
|
|
23. Introducing the Ternary Operator
|
|
|
24. A Bit of Theory Statements vs Expressions
|
|
|
25. Logical Operator Tricks & Shorthands
|
|
|
26. Logical Operators - A Quick Summary
|
|
|
27. Logical Operators & How They Work
|
|
|
28. Working with the switch-case Statement
|
|
|
29. Introducing Loops
|
|
|
30. The for Loop
|
|
|
31. The for-of Loop
|
|
|
32. The for-in Loop
|
|
|
33. The while & do-while Loops
|
|
|
34. Loops - Basics
|
|
|
35. Time to Practice Control Structures
|
|
|
36. Controlling Loops with break
|
|
|
37. Controlling Iterations with continue
|
|
|
38. More Control with Labeled Statements
|
|
|
39. break & continue
|
|
|
40. Error Handling with try-catch - An Introduction
|
|
|
41. Throwing Custom Errors
|
|
|
42. Working with try-catch to Catch & Handle Errors
|
|
|
43. Error Handling
|
|
|
44. Wrap Up
|
|
|
45. Useful Resources & Links
|
|
|
|
05. Behind the Scenes & The (Weird) Past (ES3, ES5) & Present (ES6+) of JavaScript
|
|
01. Module Introduction
|
|
|
02. ES5 vs ES6+ (Next Gen JS) - Evolution of JavaScript
|
|
|
03. var vs let & const - Introducing Block Scope
|
|
|
04. Understanding Hoisting
|
|
|
05. Strict Mode & Writing Good Code
|
|
|
06. JavaScript Specialties
|
|
|
07. How Code is Parsed & Compiled
|
|
|
08. Inside the JavaScript Engine - How the Code Executes
|
|
|
09. [DEEP DIVE] JavaScript Language vs Browser APIs
|
|
|
10. Primitive vs Reference Values
|
|
|
11. Garbage Collection & Memory Management
|
|
|
12. Wrap Up
|
|
|
13. Useful Resources & Links
|
|
|
|
06. More on Functions
|
|
01. Module Introduction
|
|
|
02. Recapping Functions Knowledge - What We Know Thus Far
|
|
|
03. Parameters vs Arguments
|
|
|
04. Functions vs Methods
|
|
|
05. Functions are Objects!
|
|
|
06. Function Expressions Storing Functions in Variables
|
|
|
07. Function Expressions vs Function Declarations
|
|
|
08. Anonymous Functions
|
|
|
09. Working on the Project Adding User Choices to the Game
|
|
|
10. Implementing the Core Game Logic
|
|
|
11. Introducing Arrow Functions
|
|
|
12. Different Arrow Function Syntaxes
|
|
|
13. Creating Functions
|
|
|
14. Outputting Messages to the User
|
|
|
15. Default Arguments in Functions
|
|
|
16. Introducing Rest Parameters (Rest Operator)
|
|
|
17. Creating Functions Inside of Functions
|
|
|
18. Understanding Callback Functions
|
|
|
19. Time to Practice Functions
|
|
|
20. Working with bind()
|
|
|
21. Functions - Advanced
|
|
|
22. Adding bind() to the Calculator Project
|
|
|
23. call() and apply()
|
|
|
24. Wrap Up
|
|
|
25. Useful Resources & Links
|
|
|
|
07. Working with the DOM (Browser HTML Code) in JavaScript
|
|
01. Module Introduction
|
|
|
02. What's the DOM
|
|
|
03. Document and Window Object
|
|
|
04. Understanding the DOM and how it's created
|
|
|
05. Nodes & Elements - Querying the DOM Overview
|
|
|
06. Selecting Elements in the DOM
|
|
|
07. Summary Node Query Methods
|
|
|
08. Exploring and Changing DOM Properties
|
|
|
09. Attributes vs Properties
|
|
|
10. Selecting Multiple Elements & Summary
|
|
|
11. DOM Basics
|
|
|
12. Time to Practice DOM Querying
|
|
|
13. Traversing the DOM - Overview
|
|
|
14. Traversing Child Nodes
|
|
|
15. Using parentNode & parentElement
|
|
|
16. Selecting Sibling Elements
|
|
|
17. DOM Traversal vs Query Methods
|
|
|
18. Styling DOM Elements
|
|
|
19. Creating Elements with JS - Overview
|
|
|
20. Adding Elements via HTML in Code
|
|
|
21. Adding Elements via createElement()
|
|
|
22. Inserting DOM Elements
|
|
|
23. Cloning DOM Nodes
|
|
|
24. Live Node Lists vs Static Node Lists
|
|
|
25. Removing Elements
|
|
|
26. Insertion & Removal Method Summary
|
|
|
27. Summary Insert, Replace, Remove
|
|
|
28. Setting Up the Practice Project
|
|
|
29. Selecting the Modal and Add Button
|
|
|
30. Opening a Modal by Changing CSS Classes
|
|
|
31. Controlling the Backdrop
|
|
|
32. Fetching and Validating User Input
|
|
|
33. Creating a Movie in JavaScript & Clearing the Input
|
|
|
34. Rendering Movie Items on the Screen
|
|
|
35. Deleting Movie Elements
|
|
|
36. Showing & Hiding the Are you sure Dialog
|
|
|
37. Starting with the Confirmation Logic
|
|
|
38. Finishing the App
|
|
|
39. Wrap Up
|
|
|
40. Useful Resources & Links
|
|
|
|
08. More on Arrays & Iterables
|
|
01. Module Introduction
|
|
|
02. What are Iterables and Array-like Objects
|
|
|
03. Creating Arrays
|
|
|
04. Which Data Can You Store In Arrays
|
|
|
05. push(), pop(), unshift(), shift() - Adding & Removing Elements
|
|
|
06. The splice() Method
|
|
|
07. Selecting Ranges & Creating Copies with slice()
|
|
|
08. Adding Arrays to Arrays with concat()
|
|
|
09. Retrieving Indexes with indexOf() & lastIndexOf()
|
|
|
10. Finding Stuff find() and findIndex()
|
|
|
11. Is it Included
|
|
|
12. Alternative to for Loops The forEach() Method
|
|
|
13. Transforming Data with map()
|
|
|
14. sort()ing and reverse()ing
|
|
|
15. Filtering Arrays with filter()
|
|
|
16. Where Arrow Functions Shine!
|
|
|
17. The Important reduce() Method
|
|
|
18. Chaining Methods in JavaScript
|
|
|
19. Arrays & Strings - split() and join()
|
|
|
20. The Spread Operator (...)
|
|
|
21. Understanding Array Destructuring
|
|
|
22. Maps & Sets - Overview
|
|
|
23. Working with Sets
|
|
|
24. Working with Maps
|
|
|
25. Maps vs Objects
|
|
|
26. Understanding WeakSet
|
|
|
27. Understanding WeakMap
|
|
|
28. Time to Practice Arrays & Iterables
|
|
|
29. Wrap Up
|
|
|
30. Useful Resources & Links
|
|
|
|
09. More on Objects
|
|
01. Module Introduction
|
|
|
02. What's an Object
|
|
|
03. Objects & Primitive Values
|
|
|
04. Objects - Recap
|
|
|
05. Adding, Modifying & Deleting Properties
|
|
|
06. Special Key Names & Square Bracket Property Access
|
|
|
07. Property Types & Property Order
|
|
|
08. Dynamic Property Access & Setting Properties Dynamically
|
|
|
09. Object Properties
|
|
|
10. Demo App & Shorthand Property Syntax
|
|
|
11. Rendering Elements based on Objects
|
|
|
12. for-in Loops & Outputting Dynamic Properties
|
|
|
13. Adding the Filter Functionality
|
|
|
14. Understanding Chaining (Property & Method Chaining)
|
|
|
15. The Object Spread Operator (...)
|
|
|
16. Understanding Object.assign()
|
|
|
17. Object Destructuring
|
|
|
18. Checking for Property Existance
|
|
|
19. Introducing this
|
|
|
20. The Method Shorthand Syntax
|
|
|
21. The this Keyword And Its Strange Behavior
|
|
|
22. call() and apply()
|
|
|
23. What the Browser (Sometimes) Does to this
|
|
|
24. this and Arrow Functions
|
|
|
25. this - Summary
|
|
|
26. this
|
|
|
27. Getters & Setters
|
|
|
28. Wrap Up
|
|
|
29. Useful Resources & Links
|
|
|
|
10. Classes & Object-oriented Programming (OOP)
|
|
01. Module Introduction
|
|
|
02. What is Object-oriented Programming (OOP)
|
|
|
03. Getting Started with OOP Code
|
|
|
04. Defining & Using a First Class
|
|
|
05. Working with Constructor Methods
|
|
|
06. Fields vs Properties
|
|
|
07. Using & Connecting Multiple Classes
|
|
|
08. Binding Class Methods & Working with this
|
|
|
09. Adding a Cart and Shop Class
|
|
|
10. Communicating Can Be Challenging!
|
|
|
11. Static Methods & Properties
|
|
|
12. First Summary & Classes vs Object Literals
|
|
|
13. Getters & Setters
|
|
|
14. Introducing Inheritance
|
|
|
15. Implementing Inheritance
|
|
|
16. Using Inheritance Everywhere
|
|
|
17. Overriding Methods and the super() Constructor
|
|
|
18. super() Constructor Execution, Order & this
|
|
|
19. Different Ways of Adding Methods
|
|
|
20. Private Properties
|
|
|
21. Pseudo-Private Properties
|
|
|
22. Time to Practice Classes & OOP
|
|
|
23. The instanceof Operator
|
|
|
24. Built-in Classes
|
|
|
25. Understanding Object Descriptors
|
|
|
26. Classes
|
|
|
27. Wrap Up
|
|
|
28. Useful Resources & Links
|
|
|
|
11. Deep Dive Constructor Functions & Prototypes
|
|
01. Module Introduction
|
|
|
02. Introducing Constructor Functions
|
|
|
03. Constructor Functions vs Classes & Understanding new
|
|
|
04. Introducing Prototypes
|
|
|
05. Prototypes - Summary
|
|
|
06. Working with Prototypes
|
|
|
07. The Prototype Chain and the Global Object
|
|
|
08. Constructor Functions & Prototypes
|
|
|
09. Classes & Prototypes
|
|
|
10. Methods in Classes & In Constructors
|
|
|
11. Built-in Prototypes in JavaScript
|
|
|
12. Setting & Getting Prototypes
|
|
|
13. Wrap Up
|
|
|
14. Useful Resources & Links
|
|
|
|
12. Practice OOP & Classes
|
|
01. Module Introduction
|
|
|
02. First Project Steps & Planning
|
|
|
03. Creating Project Lists & Parsing Element Data
|
|
|
04. Starting with the Switch Project Logic
|
|
|
05. Passing Method References Around
|
|
|
06. Moving DOM Elements
|
|
|
07. Adding a Tooltip
|
|
|
08. Adding Inheritance
|
|
|
09. Wrap Up
|
|
|
10. Useful Resources & Links
|
|
|
|
13. Back to the DOM & More Browser APIs
|
|
01. Module Introduction
|
|
|
02. Using dataset (data- Attributes)
|
|
|
03. Getting Element Box Dimensions
|
|
|
04. Working with Element Sizes & Positions
|
|
|
05. The DOM & Prototypes
|
|
|
06. Positioning the Tooltip
|
|
|
07. Handling Scrolling
|
|
|
08. Working with template Tags
|
|
|
09. Loading Scripts Dynamically
|
|
|
10. Setting Timers & Intervals
|
|
|
11. The location and history Objects
|
|
|
12. The navigator Object
|
|
|
13. Working with Dates
|
|
|
14. The Error Object & Constructor Function
|
|
|
15. Wrap Up
|
|
|
16. Useful Resources & Links
|
|
|
|
14. Working with Events
|
|
01. Module Introduction
|
|
|
02. Introduction to Events in JavaScript
|
|
|
03. Different Ways of Listening to Events
|
|
|
04. Removing Event Listeners
|
|
|
05. The event Object
|
|
|
06. Supported Event Types
|
|
|
07. Example Basic Infinite Scrolling
|
|
|
08. Working with preventDefault()
|
|
|
09. Understanding Capturing & Bubbling Phases
|
|
|
10. Event Propagation & stopPropagation()
|
|
|
11. Using Event Delegation
|
|
|
12. Triggering DOM Elements Programmatically
|
|
|
13. Event Handler Functions & this
|
|
|
14. Events
|
|
|
15. Drag & Drop - Theory
|
|
|
16. Configuring Draggable Elements
|
|
|
17. Marking the Drop Area
|
|
|
18. Dropping & Moving Data + Elements
|
|
|
19. Firefox Adjustments
|
|
|
20. Wrap Up
|
|
|
21. Useful Resources & Links
|
|
|
|
15. Advanced Function Concepts
|
|
01. Module Introduction
|
|
|
02. Pure Functions & Side-Effects
|
|
|
03. Impure vs Pure Functions
|
|
|
04. Factory Functions
|
|
|
05. Closures
|
|
|
06. Closures in Practice
|
|
|
07. Closures & Memory Management
|
|
|
08. Optional IIFEs
|
|
|
09. Introducing Recursion
|
|
|
10. Advanced Recursion
|
|
|
11. Advanced Functions
|
|
|
12. Wrap Up
|
|
|
13. Useful Resources & Links
|
|
|
|
16. More on Numbers & Strings
|
|
01. Module Introduction
|
|
|
02. How Numbers Work & Behave in JavaScript
|
|
|
03. Floating Point (Im)Precision
|
|
|
04. The BigInt Type
|
|
|
05. The Global Number and Math Objects
|
|
|
06. Example Generate Random Number Between Min Max
|
|
|
07. Exploring String Methods
|
|
|
08. Tagged Templates
|
|
|
09. Introducing Regular Expressions (RegEx)
|
|
|
10. More on Regular Expressions
|
|
|
11. Wrap Up
|
|
|
12. Useful Resources & Links
|
|
|
|
17. Async JavaScript Promises & Callbacks
|
|
01. Module Introduction
|
|
|
02. Understanding Synchronous Code Execution (Sync Code)
|
|
|
03. Understanding Asynchronous Code Execution (Async Code)
|
|
|
04. Blocking Code & The Event Loop
|
|
|
05. Sync + Async Code - The Execution Order
|
|
|
06. Multiple Callbacks & setTimeout(0)
|
|
|
07. Asynchronous Code
|
|
|
08. Getting Started with Promises
|
|
|
09. Chaining Multiple Promises
|
|
|
10. Promise Error Handling
|
|
|
11. Promise States & finally
|
|
|
12. Async await
|
|
|
13. Async await & Error Handling
|
|
|
14. Async await vs Raw Promises
|
|
|
15. Promise.all(), Promise.race() etc
|
|
|
16. Promises & async await
|
|
|
17. Wrap Up
|
|
|
18. Useful Resources & Links
|
|
|
|
18. Working with Http Requests
|
|
01. Module Introduction
|
|
|
02. What & Why
|
|
|
03. How The Web Works
|
|
|
04. More Background about Http
|
|
|
05. Getting Started with Http
|
|
|
06. Sending a GET Request
|
|
|
07. JSON Data & Parsing Data
|
|
|
08. JSON Data Deep Dive
|
|
|
09. Promisifying Http Requests (with XMLHttpRequest)
|
|
|
10. Sending Data with a POST Request
|
|
|
11. Triggering Requests via the UI
|
|
|
12. The Fetch Button Always Appends
|
|
|
13. Sending a DELETE Request
|
|
|
14. Handling Errors
|
|
|
15. Using the fetch() API
|
|
|
16. POSTing Data with the fetch() API
|
|
|
17. Adding Request Headers
|
|
|
18. fetch() & Error Handling
|
|
|
19. XMLHttpRequest vs fetch()
|
|
|
20. Working with FormData
|
|
|
21. Wrap Up
|
|
|
22. Useful Resources & Links
|
|
|
|
19. Working with JavaScript Libraries
|
|
01. Module Introduction
|
|
|
02. What & Why
|
|
|
03. Adding Libraries (Example lodash)
|
|
|
04. Example jQuery
|
|
|
05. Discovering Libraries
|
|
|
06. Axios Library & Http Requests
|
|
|
07. Third-Party Library Considerations
|
|
|
08. Wrap Up
|
|
|
09. Useful Resources & Links
|
|
|
|
20. Modular JavaScript (Working with Modules)
|
|
01. Module Introduction
|
|
|
02. Splitting Code in a Sub-optimal Way
|
|
|
03. A First Step Towards JavaScript Modules
|
|
|
04. We Need a Development Server!
|
|
|
05. First import export Work
|
|
|
06. Switching All Files To Use Modules
|
|
|
07. More Named Export Syntax Variations
|
|
|
08. Working With Default Exports
|
|
|
09. Dynamic Imports & Code Splitting
|
|
|
10. When Does Module Code Execute
|
|
|
11. Module Scope & globalThis
|
|
|
12. Modules
|
|
|
13. Wrap Up
|
|
|
14. Useful Resources & Links
|
|
|
|
21. JavaScript Tooling & Workflows
|
|
01. Module Introduction
|
|
|
02. Project Limitations & Why We Need Tools
|
|
|
03. Workflow Overview
|
|
|
04. Setting Up a npm Project
|
|
|
05. Working with npm Packages
|
|
|
06. Linting with ESLint
|
|
|
07. Configuring ESLint
|
|
|
08. Bundling with Webpack
|
|
|
09. Bonus Multiple Entry Points
|
|
|
10. Development Mode & Fixing Lazy Loading
|
|
|
11. Using webpack-dev-server
|
|
|
12. Generating Sourcemaps
|
|
|
13. Building For Production
|
|
|
14. Final Optimizations
|
|
|
15. Using Third Party Packages with npm & Webpack
|
|
|
16. Wrap Up
|
|
|
17. Useful Resources & Links
|
|
|
|
22. Utilizing Browser Storage
|
|
01. Module Introduction
|
|
|
02. Browser Storage Options
|
|
|
03. localStorage & sessionStorage
|
|
|
04. Getting Started with Cookies
|
|
|
05. Working with Cookies
|
|
|
06. Getting Started with IndexedDB
|
|
|
07. Working with IndexedDB
|
|
|
08. Wrap Up
|
|
|
09. Useful Resources & Links
|
|
|
|
23. JavaScript & Browser Support
|
|
01. Module Introduction
|
|
|
02. What Is Browser Support About
|
|
|
03. Determining Browser Support For A JavaScript Feature
|
|
|
04. Determining Required Support
|
|
|
05. Solution Feature Detection + Fallback Code
|
|
|
06. Solution Using Polyfills
|
|
|
07. Solution Transpiling Code
|
|
|
08. Improvement Automatically Detect + Add Polyfills
|
|
|
09. What about Support Outside of Browsers
|
|
|
10. Browser Support Outside of JavaScript Files
|
|
|
11. Wrap Up
|
|
|
12. Useful Resources & Links
|
|
|
|
24. Time to Practice Share My Place App
|
|
01. Module Introduction
|
|
|
02. Setting Up the Project
|
|
|
03. Getting DOM Access
|
|
|
04. Getting the User Location
|
|
|
05. Adding Feedback (Showing a Modal)
|
|
|
06. Hiding the Modal
|
|
|
07. Rendering a Map with Google Maps
|
|
|
08. Continuing without a Credit Card
|
|
|
09. Finding an Address & Getting the Coordinates
|
|
|
10. Converting User Input to Coordinates
|
|
|
11. Creating a Share Place Link
|
|
|
12. Copying the Link to the Clipboard
|
|
|
13. Rendering the Shared Place Screen
|
|
|
14. Useful Resources & Links
|
|
|
|
25. Working with JavaScript Frameworks
|
|
01. Module Introduction
|
|
|
02. What and Why
|
|
|
03. The Idea Behind React.js
|
|
|
04. Analysing a React Project
|
|
|
05. Wrap Up
|
|
|
06. Useful Resources & Links
|
|
|
|
26. Meta-Programming Symbols, Iterators, Generators, Reflect API & Proxy API
|
|
01. Module Introduction
|
|
|
02. Understanding Symbols
|
|
|
03. Well-known Symbols
|
|
|
04. Understanding Iterators
|
|
|
05. Generators & Iterable Objects
|
|
|
06. Generators Summary & Built-in Iterables Examples
|
|
|
07. The Reflect API
|
|
|
08. The Proxy API and a First Trap
|
|
|
09. Working with Proxy Traps
|
|
|
10. Wrap Up
|
|
|
11. Useful Resources & Links
|
|
|
|
27. Node.js An Introduction
|
|
01. Module Introduction
|
|
|
02. JavaScript is a Hosted Language
|
|
|
03. Installation & Basics
|
|
|
04. Understanding Modules & File Access
|
|
|
05. Working with Incoming Http Requests
|
|
|
06. Sending Responses (HTML Data)
|
|
|
07. Parsing Incoming Data
|
|
|
08. Introducing & Installing Express.js
|
|
|
09. Express.js The Basics
|
|
|
10. Extracting Data
|
|
|
11. Rendering Server-side HTML with Templates & EJS
|
|
|
12. Enhancing Our Project
|
|
|
13. Adding Basic REST Routes
|
|
|
14. Understanding CORS (Cross Origin Resource Sharing)
|
|
|
15. Sending the Location ID to the Frontend
|
|
|
16. Adding the GET Location Route
|
|
|
17. Introducing MongoDB (Database)
|
|
|
18. NodeJS Error Handling
|
|
|
19. Wrap Up
|
|
|
20. Useful Resources & Links
|
|
|
|
28. Security
|
|
01. Module Introduction
|
|
|
02. Security Hole Overview & Exposing Data in your Code
|
|
|
03. Cross-Site Scripting Attacks (XSS)
|
|
|
04. Third-Party Libraries & XSS
|
|
|
05. XSS & Exposing Confidential Details
|
|
|
06. CSRF Attacks (Cross Site Request Forgery)
|
|
|
07. CORS (Cross Origin Resource Sharing)
|
|
|
08. Wrap Up
|
|
|
09. Useful Resources & Links
|
|
|
|
29. Deploying JavaScript Code
|
|
01. Module Introduction
|
|
|
02. Deployment Steps
|
|
|
03. Different Types of Websites
|
|
|
04. Example Static Host Deployment (no Server-side Code)
|
|
|
05. Injecting Script Imports Into HTML Automatically
|
|
|
06. Example Dynamic Page Deployment (with Server-side Code)
|
|
|
07. Useful Resources & Links
|
|
|
|
30. Performance & Optimizations
|
|
01. Module Introduction
|
|
|
02. What is Performance Optimization About
|
|
|
03. Optimization Potentials
|
|
|
04. Measuring Performance
|
|
|
05. Diving Into The Browser Devtools (for Performance Measuring)
|
|
|
06. Further Resources
|
|
|
07. Preparing The Testing Setup
|
|
|
08. Optimizing Startup Time & Code Usage Coverage
|
|
|
09. Updating The DOM Correctly
|
|
|
10. Updating Lists Correctly
|
|
|
11. Optimizing The Small Things
|
|
|
12. Micro-Optimizations (Think Twice!)
|
|
|
13. Finding & Fixing Memory Leaks
|
|
|
14. Server-side Performance Optimizations
|
|
|
15. Wrap Up
|
|
|
16. Useful Resources & Links
|
|
|
|
31. Introduction to Testing
|
|
01. Module Introduction
|
|
|
02. What Is Testing Why Does It Matter
|
|
|
03. Testing Setup
|
|
|
04. Writing & Running Unit Tests
|
|
|
05. Writing & Running Integration Tests
|
|
|
06. Writing & Running e2e Tests
|
|
|
07. Dealing with Async Code
|
|
|
08. Working with Mocks
|
|
|
09. Useful Resources & Links
|
|
|
|
32. Bonus Programming Paradigms (Procedural vs Object Oriented vs Functional)
|
|
01. Module Introduction
|
|
|
02. What are Programming Paradigms
|
|
|
03. Procedural Programming in Practice
|
|
|
04. Object Oriented Programming in Practice
|
|
|
05. Functional Programming in Practice
|
|
|
06. Wrap Up
|
|
|
07. Useful Resources & Links
|
|
|
|
33. Bonus Data Structures & Algorithms Introduction
|
|
01. Module Introduction
|
|
|
02. What are Data Structures & Algorithms
|
|
|
03. A First Example
|
|
|
04. Solving the Same Problem Differently
|
|
|
05. Performance & The Big O Notation
|
|
|
06. More Time Complexities & Comparing Algorithms
|
|
|
07. More on Big O
|
|
|
08. More Examples
|
|
|
09. Diving into Data Structures & Time Complexities
|
|
|
10. Where to Learn More & Wrap Up
|
|
|
11. Useful Resources & Links
|
|
|
|
34. Bonus TypeScript Introduction
|
|
01. Module Introduction
|
|
|
02. What is TypeScript and Why would you use it
|
|
|
03. Working with Types
|
|
|
04. Core Types & Diving Deeper
|
|
|
05. Object Types, Array Types & Function Types
|
|
|
06. Advanced Types (Literal Types, Union Types, Enums)
|
|
|
07. Classes & Interfaces
|
|
|
08. Generic Types
|
|
|
09. Configuring the TypeScript Compiler
|
|
|
10. Useful Resources & Links
|
|
|
|
35. Bonus Web Components
|
|
01. Module Introduction
|
|
|
02. Web Components in Action
|
|
|
03. What are Web Components
|
|
|
04. Why Web Components
|
|
|
05. Getting Started!
|
|
|
06. Web Component Browser Support
|
|
|
07. Our Development Setup
|
|
|
08. A First Custom Element
|
|
|
09. Interacting with the Surrounding DOM
|
|
|
10. Understanding the Custom Element Lifecycle
|
|
|
11. Using connectedCallback for DOM Access
|
|
|
12. Listening to Events Inside the Component
|
|
|
13. Using Attributes on Custom Elements
|
|
|
14. Styling our Elements
|
|
|
15. Working with the Shadow DOM
|
|
|
16. Adding an HTML Template
|
|
|
17. Using Slots
|
|
|
18. Defining the Template in JavaScript
|
|
|
19. Using Style Tags in the Shadow DOM
|
|
|
20. Extending Built-in Elements
|
|
|
21. Time to Practice - The Basics
|
|
|
22. The Next Steps
|
|
|
23. Understanding Shadow DOM Projection
|
|
|
24. Styling slot Content Outside of the Shadow DOM
|
|
|
25. Styling slot Content Inside of the Shadow DOM
|
|
|
26. Styling the Host Component
|
|
|
27. Conditional Host Styling
|
|
|
28. Styling with the Host Content in Mind
|
|
|
29. Smart Dynamic Styling with CSS Variables
|
|
|
30. Cleaning Up the Overall Styling
|
|
|
31. Observing Attribute Changes
|
|
|
32. Adjusting the Component Behavior Upon Attribute Changes
|
|
|
33. Using disconnectedCallback
|
|
|
34. Adding a render() Method
|
|
|
35. Final Adjustment
|
|
|
36. The Next Steps
|
|
|
37. Creating the Basic Modal Component
|
|
|
38. Adding the Modal Container
|
|
|
39. Styling the Modal Elements
|
|
|
40. Adding Some General App Logic
|
|
|
41. Opening the Modal via CSS
|
|
|
42. Public Methods & Properties
|
|
|
43. Understanding Named Slots
|
|
|
44. Listening to Slot Content Changes
|
|
|
45. Closing the Modal
|
|
|
46. Dispatching Custom Events
|
|
|
47. Configuring Custom Events
|
|
|
48. Finishing it up!
|
|
|
49. Useful Resources & Links
|
|
|
|
36. Roundup & Next Steps
|
![JavaScript - The Complete Guide 2020 (Beginner + Advanced) - [Udemy][Anglais][st-Anglais][MP4]](/static/img/no-torrent-image.png "JavaScript - The Complete Guide 2020 (Beginner + Advanced) - [Udemy][Anglais][st-Anglais][MP4]")
