Mô tả

Join the most comprehensive and in-depth JavaScript course on Udemy and learn JavaScript from the ground up, in great detail with this bestselling course!

JavaScript is THE most important programming language you need to learn as a web developer - and with this course, you make sure that you will not miss a single thing you have to know as a JavaScript developer!

This is the most comprehensive and modern course you can find on JavaScript - it's based on all my JavaScript knowledge AND teaching experience. It's both a complete guide, starting with the core basics of the language, as well as an extensive reference of the JavaScript language and environment, ensuring that both newcomers as well as experienced JavaScript developers get a lot out of this course!

It's a huge course because it's packed with important knowledge and helpful content. From the core basics, over advanced concepts and JavaScript specialties, all the way up to expert topics like performance optimization and testing - this course has it all. My goal was to create your go-to resource for the JavaScript language, which you can not just use for learning it but also as a resource you can come back to and look up important topics.

The course is based on my experience as a long-term JavaScript developer as well as a teacher with more than 2,000,000 students on Udemy as well as on my YouTube channel Academind. It's packed with examples, demos, projects, assignments, quizzes and of course videos - all with the goal of giving you the best possible way of learning JavaScript.

What's in the course?

This course is obviously packed with content - I therefore strongly recommend that you check out the full course curriculum to get a clear idea of all the topics covered in the course. In general, here's what you'll find in the course:

  • Modern JavaScript from the start: The JavaScript syntax changed over time - in this course, you'll learn the latest syntax from the start (you'll also learn about the old one though, so that you can work in ANY JS project)

  • ALL the Basics: Variables, constants, functions, how scripts are loaded etc

  • Arrays & Objects: We'll explore these very important data structures in great detail

  • Control Structures: Understand how to run code conditionally and in loops

  • A look behind the Scenes: How JavaScript engines work behind the scenes and what that means for us

  • Deep dives into Core Concepts: ALL the special things about JavaScript function, different syntaxes

  • Working with the DOM: How to manipulate web pages dynamically via JavaScript (including deep dives and different use-cases)

  • Events in JavaScript: Learn how to listen to a broad variety of events (e.g. drag & drop) and execute appropriate code

  • Classes & Object-oriented Programming: Learn how to work with classes, prototypes, the "this" keyword, constructor functions and much more

  • Asynchronous and Synchronous Programming: We'll explore callbacks, promises, async/ await and other important tools and language features to execute code correctly

  • Http Requests: Learn how to send Http requests via JavaScript

  • Tooling, Optimizations & Browser Support: Code splitting, producing small code and ensuring that scripts work in all browsers  - this matters and hence is covered in great detail

  • Libraries & Frameworks: Learn about libraries like Axios or frameworks like React.js - why they matter and how to use them

  • Node.js: Whilst focusing on the browser-side for the majority of the course (because the syntax is the same), we'll also have a dedicated section on Node.js to learn all about that JS host environment

  • Security & Performance Optimizations: Of course security matters, so does performance - no surprise that both is covered in the course!

  • Automated Testing: Testing manually is hard work and can be unreliable - in this course you'll also get an introduction into automated testing

What are the course prerequisites?

  • NO JavaScript knowledge is required - you'll learn it from scratch!

  • You also need NO programming experience other than basic web development knowledge (e.g. how the web works)

  • Basic HTML and CSS knowledge is recommended but not a must-have

Bạn sẽ học được gì

Learn JavaScript from scratch and in great detail - from beginner to advanced

All core features and concepts you need to know in modern JavaScript development

Everything you need to become a JavaScript expert and apply for JavaScript jobs

Project-driven learning with plenty of examples

All about variables, functions, objects and arrays

Object-oriented programming

Deep dives into prototypes, JavaScript engines & how it works behind the scenes

Manipulating web pages (= the DOM) with JavaScript

Event handling, asynchronous coding and Http requests

Meta-programming, performance optimization, memory leak busting

Testing, security and deployment

And so much more!

Yêu cầu

  • NO prior JavaScript knowledge is required
  • Basic web development knowledge is recommended
  • Basic understanding of HTML and CSS helps but is NOT required

Nội dung khoá học

36 sections

Introduction

14 lectures
Introduction
01:50
What is JavaScript?
03:46
JavaScript in Action!
09:08
Join our Online Learning Community
00:24
How JavaScript Is Executed
03:14
Dynamic vs Weakly Typed Languages
03:28
JavaScript Executes In A Hosted Environment
04:40
Course Outline - What's In This Course?
06:00
How To Get The Most Out Of This Course
02:36
Using Course Resources
01:01
JavaScript vs Java
04:02
A Brief History Of JavaScript
06:03
Setting Up a Development Environment
11:12
Course FAQs
02:20

Basics: Variables, Data Types, Operators & Functions

51 lectures
Module Introduction
01:17
Setting Up the Project
04:25
More on Version Control & Git
00:38
Adding JavaScript to the Website
06:42
Introducing Variables & Constants
05:17
Declaring & Defining Variables
07:10
Working with Variables & Operators
06:17
Variables & Operators
6 questions
Exercise: Variables & Operators
1 question
Understanding the Starting Code
01:21
Data Types: Numbers & Strings (Text)
06:01
Using Constants
05:11
More on Strings
15:51
Data Types & Constants
5 questions
Time to Practice: Variables, Constants, Operators & Core Data Types
1 question
Introducing Functions
05:50
Adding A Custom Function
11:22
Code Styles, Conventions & Syntax
01:53
Returning Values
04:31
Exercise: Functions
1 question
The (Un)Importance of Code Order
04:34
An Introduction to Global & Local Scope
05:31
"Shadowed Variables"
00:48
More about the "return" Statement
02:24
Executing Functions "Indirectly"
11:10
"Indirect" vs "Direct" Function Execution - Summary
01:09
Exercise: Executing Functions Directly & Indirectly
1 question
Functions & Scope
6 questions
Time to Practice: Functions
1 question
Converting Data Types
06:14
Mixing Numbers & Strings
00:32
Splitting Code into Functions
05:49
Connecting all Buttons to Functions
07:43
Working with Code Comments
04:09
More Operators!
06:39
More Core Data Types!
04:31
Using Arrays
08:53
Exercise: Arrays
1 question
Creating Objects
06:02
Exercise: Objects
1 question
Objects - Common Syntax Gotchas
00:33
Accessing Object Data
02:51
Arrays & Objects
5 questions
Adding a Re-Usable Function That Uses Objects
05:24
undefined, null & NaN
06:20
The "typeof" Operator
03:12
"undefined", "null" & "NaN"
4 questions
Importing Scripts Correctly with "defer" & "async"
14:37
Importing JavaScript - Summary
00:06
Wrap Up
02:13
Useful Resources & Links
00:23

Efficient Development & Debugging

19 lectures
Module Introduction
01:28
Efficient Development & Debugging - An Overview
03:18
Configuring the IDE Look & Feel
02:25
Using Shortcuts
04:12
Working with Auto-Completion & IDE Hints
04:34
Installing IDE Extensions
02:04
Tweaking Editor Settings
02:15
Utilizing Different IDE Views
01:41
Finding Help & Working with MDN
05:53
The ECMAScript Standard
00:18
How to "google" Correctly
01:44
Debugging JavaScript - An Overview
03:17
An Error Message! No Reason To Panic!
04:46
Using console.log() to look "into the Code"
03:49
Next-Level Debugging with the Chrome Devtools & Breakpoints
08:20
Testing Code Changes Directly in the Devtools
02:05
Debugging Code directly Inside VS Code
04:55
Wrap Up
01:22
Useful Resources & Links
00:12

Working with Control Structures (if Statements, Loops, Error Handling)

48 lectures
Module Introduction
02:26
Introducing "if" Statements & Boolean (Comparison) Operators
09:26
Using Booleans in Conditions & More on Text Comparisons
01:05
Using "if" Statements
07:23
Working with "if", "else" and "else-if"
05:10
Exercise: Getting Started with if Statements
1 question
Beware When Comparing Objects & Arrays for Equality!
04:06
The Logical AND and OR Operators
09:10
Understanding Operator Precedence
07:20
if & Boolean Operators - The Basics
7 questions
Beyond true/ false: "Truthy" and "Falsy" Values
07:30
Coercion vs Conversion
01:08
Falsy and Truthy Values
4 questions
Setting Up a Bigger Example Project (The "Monster Killer")
02:59
Adding an "Attack" Function
07:57
Using "if" Statements for Checking the Win-Condition
09:17
Adding More "if" Statements & A "Strong Attack" Functionality
07:41
Time for a "Heal Player" Functionality!
10:15
Controlling the Conditional Bonus Life (Without Boolean Operators!)
05:59
Adding a "Reset Game" Functionality
06:00
Validating User Input
06:17
Utilizing Global Constants as Identifiers in Conditional Code
03:20
Adding a Conditional Battle Log
16:37
Introducing the Ternary Operator
07:31
A Bit of Theory: Statements vs Expressions
01:40
Logical Operator "Tricks" & Shorthands
12:58
Logical Operators - A Quick Summary
01:03
Logical Operators & How They Work
8 questions
Working with the "switch-case" Statement
07:10
Introducing Loops
06:40
The "for" Loop
07:38
Exercise: for Loops
1 question
The "for-of" Loop
05:16
The "for-in" Loop
06:49
The "while" & "do-while" Loops
08:00
Loops - Basics
7 questions
Time to Practice: Control Structures
1 question
Controlling Loops with "break"
08:11
Controlling Iterations with "continue"
02:21
More Control with Labeled Statements
06:26
break & continue
6 questions
Error Handling with "try-catch" - An Introduction
02:25
Throwing Custom Errors
05:16
Working with "try-catch" to Catch & Handle Errors
08:14
Exercise: Throwing & Handling Errors
1 question
Error Handling
3 questions
Wrap Up
03:21
Useful Resources & Links
00:10

Behind the Scenes & The (Weird) Past (ES3, ES5) & Present (ES6+) of JavaScript

13 lectures
Module Introduction
01:43
ES5 vs ES6+ ("Next Gen JS") - Evolution of JavaScript
08:14
var vs let & const - Introducing "Block Scope"
14:32
Understanding "Hoisting"
04:07
Strict Mode & Writing Good Code
05:46
"JavaScript Specialties"
3 questions
How Code is Parsed & Compiled
08:16
Inside the JavaScript Engine - How the Code Executes
15:59
[DEEP DIVE] JavaScript Language vs Browser APIs
01:42
Primitive vs Reference Values
19:24
Garbage Collection & Memory Management
12:00
Wrap Up
01:55
Useful Resources & Links
00:10

More on Functions

25 lectures
Module Introduction
01:31
Recapping Functions Knowledge - What We Know Thus Far
01:52
Parameters vs Arguments
00:26
Functions vs Methods
05:46
Functions are Objects!
02:47
Function Expressions: Storing Functions in Variables
05:12
Function Expressions vs Function Declarations
02:47
Anonymous Functions
05:54
Working on the Project: Adding User Choices to the Game
07:44
Implementing the Core Game Logic
07:20
Introducing Arrow Functions
08:41
Different Arrow Function Syntaxes
01:08
Creating Functions
3 questions
Outputting Messages to the User
03:53
Default Arguments in Functions
10:45
Introducing Rest Parameters ("Rest Operator")
08:57
Creating Functions Inside of Functions
03:04
Understanding Callback Functions
06:09
Time to Practice: Functions
1 question
Working with "bind()"
08:39
Functions - Advanced
3 questions
Adding bind() to the Calculator Project
03:47
call() and apply()
01:18
Wrap Up
02:10
Useful Resources & Links
00:09

Working with the DOM (Browser HTML Code) in JavaScript

42 lectures
Module Introduction
01:48
What's the "DOM"?
06:00
Document and Window Object
06:20
Understanding the DOM and how it's created
07:07
Nodes & Elements - Querying the DOM Overview
05:55
Selecting Elements in the DOM
09:54
Exercise: Selecting Elements in the DOM
1 question
Summary: Node Query Methods
01:00
Exploring and Changing DOM Properties
07:37
Attributes vs Properties
08:58
Selecting Multiple Elements & Summary
05:13
DOM Basics
5 questions
Time to Practice: DOM Querying
1 question
Traversing the DOM - Overview
06:22
Traversing Child Nodes
09:15
Using parentNode & parentElement
05:01
Selecting Sibling Elements
04:05
DOM Traversal vs Query Methods
04:35
Styling DOM Elements
12:18
Creating Elements with JS - Overview
02:42
Adding Elements via HTML in Code
07:42
Adding Elements via createElement()
05:42
Exercise: Adding Elements
1 question
Inserting DOM Elements
08:15
Cloning DOM Nodes
01:45
Live Node Lists vs Static Node Lists
04:55
Removing Elements
01:56
Insertion & Removal Method Summary
02:38
Summary: Insert, Replace, Remove
01:52
Setting Up the Practice Project
02:16
Selecting the Modal and "Add" Button
08:58
Opening a Modal by Changing CSS Classes
05:01
Controlling the Backdrop
08:04
Fetching and Validating User Input
08:06
Creating a Movie in JavaScript & Clearing the Input
04:00
Rendering Movie Items on the Screen
08:24
Deleting Movie Elements
09:12
Showing & Hiding the "Are you sure?" Dialog
07:08
Starting with the Confirmation Logic
04:29
Finishing the App
11:45
Wrap Up
01:55
Useful Resources & Links
00:12

More on Arrays & Iterables

31 lectures
Module Introduction
01:08
What are "Iterables" and "Array-like Objects"?
02:11
Creating Arrays
08:55
Which Data Can You Store In Arrays?
03:47
push(), pop(), unshift(), shift() - Adding & Removing Elements
06:59
The splice() Method
05:37
Selecting Ranges & Creating Copies with slice()
06:06
Adding Arrays to Arrays with concat()
02:23
Retrieving Indexes with indexOf() /& lastIndexOf()
03:47
Finding Stuff: find() and findIndex()
05:20
Is it Included?
01:20
Alternative to for Loops: The forEach() Method
04:24
Transforming Data with map()
02:38
Exercise: map()
1 question
sort()ing and reverse()ing
04:15
Filtering Arrays with filter()
02:35
Where Arrow Functions Shine!
01:31
The Important reduce() Method
07:33
Chaining Methods in JavaScript
00:48
Arrays & Strings - split() and join()
04:21
The Spread Operator (...)
10:31
Understanding Array Destructuring
04:24
Maps & Sets - Overview
04:16
Working with Sets
07:21
Working with Maps
09:30
Maps vs Objects
03:41
Understanding WeakSet
04:50
Understanding WeakMap
02:51
Time to Practice: Arrays & Iterables
1 question
Wrap Up
01:25
Useful Resources & Links
00:12

More on Objects

29 lectures
Module Introduction
01:38
What's an Object?
05:54
Objects & Primitive Values
00:41
Objects - Recap
02:42
Adding, Modifying & Deleting Properties
06:46
Special Key Names & Square Bracket Property Access
08:36
Property Types & Property Order
03:55
Dynamic Property Access & Setting Properties Dynamically
04:11
Object Properties
4 questions
Demo App & Shorthand Property Syntax
09:22
Rendering Elements based on Objects
05:36
for-in Loops & Outputting Dynamic Properties
05:24
Adding the Filter Functionality
05:38
Understanding "Chaining" (Property & Method Chaining)
01:51
The Object Spread Operator (...)
05:54
Understanding Object.assign()
02:08
Object Destructuring
06:13
Checking for Property Existance
02:42
Introducing "this"
05:52
The Method Shorthand Syntax
01:07
The "this" Keyword And Its Strange Behavior
05:41
call() and apply()
03:22
What the Browser (Sometimes) Does to "this"
02:33
"this" and Arrow Functions
10:36
"this" - Summary
01:15
"this"
6 questions
Getters & Setters
07:05
Wrap Up
01:33
Useful Resources & Links
00:10

Classes & Object-oriented Programming (OOP)

28 lectures
Module Introduction
01:55
What is "Object-oriented Programming" (OOP)?
03:17
Getting Started with OOP Code
12:10
Defining & Using a First Class
07:17
Working with Constructor Methods
04:51
Fields vs Properties
02:19
Using & "Connecting" Multiple Classes
09:06
Binding Class Methods & Working with "this"
04:57
Adding a Cart and Shop Class
04:37
Communicating Can Be Challenging!
03:54
Static Methods & Properties
07:51
First Summary & Classes vs Object Literals
04:06
Getters & Setters
05:43
Introducing Inheritance
02:34
Implementing Inheritance
11:50
Using Inheritance Everywhere
06:51
Overriding Methods and the super() Constructor
06:00
super() Constructor Execution, Order & "this"
06:46
Different Ways of Adding Methods
05:51
Private Properties
07:24
"Pseudo-Private" Properties
00:32
Time to Practice: Classes & OOP
1 question
The "instanceof" Operator
04:30
Built-in Classes
01:09
Understanding Object Descriptors
07:35
Classes
5 questions
Wrap Up
01:51
Useful Resources & Links
00:09

Deep Dive: Constructor Functions & Prototypes

14 lectures
Module Introduction
01:34
Introducing Constructor Functions
04:02
Constructor Functions vs Classes & Understanding "new"
04:17
Introducing Prototypes
16:46
Prototypes - Summary
00:59
Working with Prototypes
05:19
The Prototype Chain and the Global "Object"
08:26
Constructor Functions & Prototypes
4 questions
Classes & Prototypes
05:24
Methods in Classes & In Constructors
10:16
Built-in Prototypes in JavaScript
02:12
Setting & Getting Prototypes
10:58
Wrap Up
02:49
Useful Resources & Links
00:09

Practice: OOP & Classes

10 lectures
Module Introduction
01:38
First Project Steps & Planning
04:46
Creating Project Lists & Parsing Element Data
04:08
Starting with the "Switch Project" Logic
09:59
Passing Method References Around
07:02
Moving DOM Elements
11:49
Adding a Tooltip
08:58
Adding Inheritance
06:13
Wrap Up
00:57
Useful Resources & Links
00:07

Back to the DOM & More Browser APIs

16 lectures
Module Introduction
02:31
Using "dataset" (data-* Attributes)
06:51
Getting Element Box Dimensions
05:54
Working with Element Sizes & Positions
04:56
The DOM & Prototypes
02:21
Positioning the Tooltip
10:57
Handling Scrolling
05:36
Working with <template> Tags
05:14
Loading Scripts Dynamically
07:35
Setting Timers & Intervals
07:37
The "location" and "history" Objects
04:20
The "navigator" Object
04:50
Working with Dates
03:17
The "Error" Object & Constructor Function
03:21
Wrap Up
00:43
Useful Resources & Links
00:12

Working with Events

21 lectures
Module Introduction
01:31
Introduction to Events in JavaScript
06:18
Different Ways of Listening to Events
06:59
Removing Event Listeners
05:14
The "event" Object
05:43
Supported Event Types
08:00
Example: Basic Infinite Scrolling
01:02
Working with "preventDefault()"
05:15
Understanding "Capturing" & "Bubbling" Phases
02:03
Event Propagation & "stopPropagation()"
07:39
Using Event Delegation
08:33
Triggering DOM Elements Programmatically
03:40
Event Handler Functions & "this"
02:28
Events
4 questions
Drag & Drop - Theory
04:59
Configuring Draggable Elements
06:23
Marking the "Drop Area"
08:52
Dropping & Moving Data + Elements
06:58
Firefox Adjustments
01:40
Wrap Up
01:15
Useful Resources & Links
00:11

Advanced Function Concepts

13 lectures
Module Introduction
00:57
Pure Functions & Side-Effects
06:13
Impure vs Pure Functions
02:00
Factory Functions
05:41
Closures
07:45
Closures in Practice
07:01
Closures & Memory Management
01:23
Optional: IIFEs
00:57
Introducing "Recursion"
07:32
Advanced Recursion
09:01
Advanced Functions
4 questions
Wrap Up
01:14
Useful Resources & Links
00:10

More on Numbers & Strings

12 lectures
Module Introduction
00:53
How Numbers Work & Behave in JavaScript
07:46
Floating Point (Im)Precision
11:04
The BigInt Type
03:36
The Global "Number" and "Math" Objects
02:47
Example: Generate Random Number Between Min/ Max
05:33
Exploring String Methods
01:43
Tagged Templates
10:28
Introducing Regular Expressions ("RegEx")
04:30
More on Regular Expressions
07:25
Wrap Up
01:20
Useful Resources & Links
00:10

Async JavaScript: Promises & Callbacks

18 lectures
Module Introduction
01:12
Understanding Synchronous Code Execution ("Sync Code")
02:51
Understanding Asynchronous Code Execution ("Async Code")
05:44
Blocking Code & The "Event Loop"
10:30
Sync + Async Code - The Execution Order
04:03
Multiple Callbacks & setTimeout(0)
03:20
Asynchronous Code
3 questions
Getting Started with Promises
08:25
Chaining Multiple Promises
05:53
Promise Error Handling
07:46
Promise States & "finally"
00:41
Async/ await
09:11
Async/ await & Error Handling
03:07
Async/ await vs "Raw Promises"
04:56
Promise.all(), Promise.race() etc.
07:59
Promises & async/ await
5 questions
Wrap Up
01:27
Useful Resources & Links
00:10

Working with Http Requests

22 lectures
Module Introduction
01:07
What & Why
05:03
How The Web Works
00:14
More Background about Http
05:24
Getting Started with Http
03:35
Sending a GET Request
03:46
JSON Data & Parsing Data
09:14
JSON Data Deep Dive
01:16
Promisifying Http Requests (with XMLHttpRequest)
03:49
Sending Data with a POST Request
04:55
Triggering Requests via the UI
03:13
The "Fetch" Button Always Appends
00:11
Sending a DELETE Request
04:56
Handling Errors
05:03
Using the fetch() API
07:10
POSTing Data with the fetch() API
02:38
Adding Request Headers
03:01
fetch() & Error Handling
07:11
XMLHttpRequest vs fetch()
01:42
Working with FormData
06:58
Wrap Up
01:17
Useful Resources & Links
00:13

Working with JavaScript Libraries

9 lectures
Module Introduction
00:59
What & Why
02:55
Adding Libraries (Example: lodash)
09:10
Example: jQuery
02:30
Discovering Libraries
03:25
Axios Library & Http Requests
10:46
Third-Party Library Considerations
04:54
Wrap Up
00:59
Useful Resources & Links
00:07

Modular JavaScript (Working with Modules)

14 lectures
Module Introduction
00:56
Splitting Code in a Sub-optimal Way
07:12
A First Step Towards JavaScript Modules
03:25
We Need a Development Server!
05:58
First import / export Work
03:41
Switching All Files To Use Modules
04:26
More Named Export Syntax Variations
06:12
Working With Default Exports
03:35
Dynamic Imports & Code Splitting
05:24
When Does Module Code Execute?
02:06
Module Scope & globalThis
06:18
Modules
4 questions
Wrap Up
01:37
Useful Resources & Links
00:09

JavaScript Tooling & Workflows

18 lectures
Module Introduction
03:23
Project Limitations & Why We Need Tools
08:11
Workflow Overview
02:42
Setting Up a npm Project
03:45
Working with npm Packages
03:39
Linting with ESLint
08:38
Configuring ESLint
00:27
Important: Webpack Version & Configuring npm Scripts
00:27
Bundling with Webpack
15:13
Bonus: Multiple Entry Points
00:47
Development Mode & Fixing "Lazy Loading"
04:00
Using webpack-dev-server
03:14
Generating Sourcemaps
03:05
Building For Production
03:45
Final Optimizations
06:35
Using Third Party Packages with npm & Webpack
04:06
Wrap Up
01:39
Useful Resources & Links
00:10

Utilizing Browser Storage

9 lectures
Module Introduction
01:05
Browser Storage Options
07:21
localStorage & sessionStorage
10:43
Getting Started with Cookies
06:06
Working with Cookies
08:10
Getting Started with IndexedDB
08:55
Working with IndexedDB
04:06
Wrap Up
00:48
Useful Resources & Links
00:11

JavaScript & Browser Support

12 lectures
Module Introduction
01:29
What Is "Browser Support" About?
07:36
Determining Browser Support For A JavaScript Feature
08:20
Determining Required Support
03:29
Solution: Feature Detection + Fallback Code
09:55
Solution: Using Polyfills
03:18
Solution: Transpiling Code
12:02
Improvement: Automatically Detect + Add Polyfills
11:02
What about Support Outside of Browsers?
00:58
Browser Support Outside of JavaScript Files
02:36
Wrap Up
01:18
Useful Resources & Links
00:10

Time to Practice: Share My Place App

15 lectures
Module Introduction
00:53
Note: Use the LTS Version of NodeJS
00:07
Setting Up the Project
03:05
Getting DOM Access
04:33
Getting the User Location
06:27
Adding Feedback (Showing a Modal)
11:16
Hiding the Modal
02:38
Rendering a Map with Google Maps
14:16
Continuing without a Credit Card
01:00
Finding an Address & Getting the Coordinates
08:22
Converting User Input to Coordinates
03:35
Creating a "Share Place" Link
08:30
Copying the Link to the Clipboard
03:36
Rendering the "Shared Place" Screen
06:22
Useful Resources & Links
00:07

Working with JavaScript Frameworks

6 lectures
Module Introduction
01:06
What and Why?
07:35
The Idea Behind React.js
02:46
Analysing a React Project
17:38
Wrap Up
01:35
Useful Resources & Links
00:10

Meta-Programming: Symbols, Iterators, Generators, Reflect API & Proxy API

11 lectures
Module Introduction
01:51
Understanding Symbols
08:27
Well-known Symbols
05:15
Understanding Iterators
05:32
Generators & Iterable Objects
11:02
Generators Summary & Built-in Iterables Examples
03:22
The Reflect API
07:10
The Proxy API and a First "Trap"
09:04
Working with Proxy Traps
02:57
Wrap Up
01:37
Useful Resources & Links
00:16

Node.js: An Introduction

20 lectures
Module Introduction
01:42
JavaScript is a Hosted Language
02:21
Installation & Basics
06:16
Understanding Modules & File Access
04:39
Working with Incoming Http Requests
05:46
Sending Responses (HTML Data)
04:01
Parsing Incoming Data
10:53
Introducing & Installing Express.js
02:48
Express.js: The Basics
06:34
Extracting Data
04:23
Rendering Server-side HTML with Templates & EJS
06:52
Enhancing Our Project
03:44
Adding Basic REST Routes
12:09
Understanding CORS (Cross Origin Resource Sharing)
05:13
Sending the Location ID to the Frontend
02:16
Adding the GET Location Route
07:16
Introducing MongoDB (Database)
14:44
NodeJS Error Handling
01:08
Wrap Up
01:50
Useful Resources & Links
00:10

Security

9 lectures
Module Introduction
01:35
Security Hole Overview & Exposing Data in your Code
06:45
Cross-Site Scripting Attacks (XSS)
14:39
Third-Party Libraries & XSS
05:17
XSS & Exposing Confidential Details
3 questions
CSRF Attacks (Cross Site Request Forgery)
04:16
CORS (Cross Origin Resource Sharing)
02:53
Wrap Up
01:30
Useful Resources & Links
00:09

Deploying JavaScript Code

7 lectures
Module Introduction
01:11
Deployment Steps
07:29
Different Types of Websites
00:32
Example: Static Host Deployment (no Server-side Code)
09:43
Injecting Script Imports Into HTML Automatically
00:18
Example: Dynamic Page Deployment (with Server-side Code)
12:45
Useful Resources & Links
00:10

Performance & Optimizations

16 lectures
Module Introduction
01:49
What is "Performance Optimization" About?
06:16
Optimization Potentials
06:48
Measuring Performance
03:42
Diving Into The Browser Devtools (for Performance Measuring)
15:30
Further Resources
02:13
Preparing The Testing Setup
04:03
Optimizing Startup Time & Code Usage / Coverage
11:51
Updating The DOM Correctly
09:53
Updating Lists Correctly
08:11
Optimizing The Small Things
03:58
Micro-Optimizations (Think Twice!)
08:49
Finding & Fixing Memory Leaks
09:43
Server-side Performance Optimizations
01:22
Wrap Up
03:26
Useful Resources & Links
00:13

Introduction to Testing

9 lectures
Module Introduction
00:49
What Is Testing? Why Does It Matter?
07:09
Testing Setup
04:10
Writing & Running Unit Tests
11:15
Writing & Running Integration Tests
06:03
Writing & Running e2e Tests
10:16
Dealing with Async Code
10:20
Working with Mocks
07:51
Useful Resources & Links
00:13

Bonus: Programming Paradigms (Procedural vs Object Oriented vs Functional)

7 lectures
Module Introduction
00:48
What are Programming Paradigms?
03:01
Procedural Programming in Practice
08:53
Object Oriented Programming in Practice
13:20
Functional Programming in Practice
13:52
Wrap Up
03:26
Useful Resources & Links
00:07

Bonus: Data Structures & Algorithms Introduction

11 lectures
Module Introduction
02:02
What are "Data Structures" & "Algorithms"?
04:22
A First Example
10:22
Solving the Same Problem Differently
07:26
Performance & The "Big O" Notation
11:44
More Time Complexities & Comparing Algorithms
03:36
More on Big O
05:23
More Examples
10:15
Diving into Data Structures & Time Complexities
12:07
Where to Learn More & Wrap Up
03:22
Useful Resources & Links
00:13

Bonus: TypeScript Introduction

10 lectures
Module Introduction
01:11
What is TypeScript and Why would you use it?
04:58
Working with Types
10:05
Core Types & Diving Deeper
17:26
Object Types, Array Types & Function Types
09:22
Advanced Types (Literal Types, Union Types, Enums)
09:20
Classes & Interfaces
12:02
Generic Types
05:02
Configuring the TypeScript Compiler
05:11
Useful Resources & Links
00:09

Bonus: Web Components

49 lectures
Module Introduction
02:01
Web Components in Action
06:30
What are Web Components?
03:22
Why Web Components?
02:44
Getting Started!
04:56
Web Component Browser Support
02:44
Our Development Setup
03:53
A First Custom Element
08:17
Interacting with the Surrounding DOM
05:04
Understanding the Custom Element Lifecycle
02:51
Using "connectedCallback" for DOM Access
02:05
Listening to Events Inside the Component
09:12
Using Attributes on Custom Elements
04:45
Styling our Elements
04:08
Working with the "Shadow DOM"
05:00
Adding an HTML Template
05:40
Using Slots
01:50
Defining the Template in JavaScript
03:21
Using Style Tags in the Shadow DOM
02:40
Extending Built-in Elements
07:33
Time to Practice - The Basics
1 question
The Next Steps
00:49
Understanding Shadow DOM Projection
02:26
Styling "slot" Content Outside of the Shadow DOM
03:44
Styling "slot" Content Inside of the Shadow DOM
03:10
Styling the Host Component
04:42
Conditional Host Styling
02:49
Styling with the Host Content in Mind
02:27
Smart Dynamic Styling with CSS Variables
06:20
Cleaning Up the Overall Styling
03:22
Observing Attribute Changes
06:17
Adjusting the Component Behavior Upon Attribute Changes
02:34
Using "disconnectedCallback"
06:10
Adding a render() Method
06:13
Final Adjustment
00:12
The Next Steps
00:52
Creating the Basic Modal Component
06:33
Adding the Modal Container
02:29
Styling the Modal Elements
05:35
Adding Some General App Logic
03:49
Opening the Modal via CSS
05:23
Public Methods & Properties
06:37
Understanding Named Slots
05:45
Listening to Slot Content Changes
05:10
Closing the Modal
06:57
Dispatching Custom Events
03:40
Configuring Custom Events
04:52
Finishing it up!
04:51
Useful Resources & Links
00:07

Roundup & Next Steps

2 lectures
Course Roundup
00:55
Bonus! (Next Steps Overview / Other Topics)
00:20

Đánh giá của học viên

Chưa có đánh giá
Course Rating
5
0%
4
0%
3
0%
2
0%
1
0%

Bình luận khách hàng

Viết Bình Luận

Bạn đánh giá khoá học này thế nào?

image

Đăng ký get khoá học Udemy - Unica - Gitiho giá chỉ 50k!

Get khoá học giá rẻ ngay trước khi bị fix.