Your 2nd JavaScript Course- Advanced Concepts and Algorithms

Your 2nd JavaScript Course: Advanced Concepts and Algorithms, available at $59.99, has an average rating of 4.2, with 199 lectures, based on 128 reviews, and has 1139 subscribers.

You will learn about Understand how JavaScript works: queue, stack, heap, stack overflow, event loop, task queue, etc. Master ES6 new syntaxes: let, map, set, Symbol, iterator, generator, reflect, promise, proxy, etc. Destructuring assignment Completely understand the JavaScript inheritance and the prototype chain ES6 Module and CommonJS Constructors and classes Real-life creative ways of designing constructors and inheritance programs The strict mode Tail call optimization Recursion Deep and shallow object copy Two-way data binding Data structure Sorting algorithms This course is ideal for individuals who are Students who want to take their JavaScript skill to the next level or Students who need to enhance their JavaScript knowledge foundation or Students who need to master advanced and confusing JavaScript topics like prototype chain, event loop, closure, etc. or Developers who need to know more about the running mechanism of JavaScript or Developers who need to improve the efficiency and quality of their codes It is particularly useful for Students who want to take their JavaScript skill to the next level or Students who need to enhance their JavaScript knowledge foundation or Students who need to master advanced and confusing JavaScript topics like prototype chain, event loop, closure, etc. or Developers who need to know more about the running mechanism of JavaScript or Developers who need to improve the efficiency and quality of their codes.

Enroll now: Your 2nd JavaScript Course: Advanced Concepts and Algorithms

Summary

Title: Your 2nd JavaScript Course: Advanced Concepts and Algorithms

Price: $59.99

Average Rating: 4.2

Number of Lectures: 199

Number of Published Lectures: 199

Number of Curriculum Items: 199

Number of Published Curriculum Objects: 199

Original Price: $89.99

Quality Status: approved

Status: Live

What You Will Learn

Understand how JavaScript works: queue, stack, heap, stack overflow, event loop, task queue, etc.

Master ES6 new syntaxes: let, map, set, Symbol, iterator, generator, reflect, promise, proxy, etc.

Destructuring assignment

Completely understand the JavaScript inheritance and the prototype chain

ES6 Module and CommonJS

Constructors and classes

Real-life creative ways of designing constructors and inheritance programs

The strict mode

Tail call optimization

Recursion

Deep and shallow object copy

Two-way data binding

Data structure

Sorting algorithms

Who Should Attend

Students who want to take their JavaScript skill to the next level

Students who need to enhance their JavaScript knowledge foundation

Students who need to master advanced and confusing JavaScript topics like prototype chain, event loop, closure, etc.

Developers who need to know more about the running mechanism of JavaScript

Developers who need to improve the efficiency and quality of their codes

Target Audiences

Students who want to take their JavaScript skill to the next level

Students who need to enhance their JavaScript knowledge foundation

Students who need to master advanced and confusing JavaScript topics like prototype chain, event loop, closure, etc.

Developers who need to know more about the running mechanism of JavaScript

Developers who need to improve the efficiency and quality of their codes

About this course:

This is a JavaScript enhancement course, designed to help junior JavaScript developers gain a wider and deeper understanding of JavaScript.

If you want to take the leap from a junior JavaScript developer to a senior one, then you have found the right course.

What you will learn: 

You will learn ES6 new features like destructuring assignment, async/await, reflect, proxy, symbol, iterator, generator, etc.

Then you will learn the JavaScript object system and prototypal inheritance in the most detailed way. You will learn every method the Object constructor has.

To completely understand how JavaScript works, you will learn advanced topics like thread, process, stack, queue, heap, task queue, event loop, recursion, deep and shallow object copy, etc.

To further boost your coding skills, you will also learn 8 sorting algorithms: bubble sorting, cocktail sorting, quick sorting, counting sorting, insertionsorting, bucket sorting, selectionsorting, and heap sorting.

You will also develop a proper understanding of linear and non-linear data structures, including array, linked list, binary search tree, max heap, min heap, etc.

What you will achieve:

After this course, you will develop a solid JavaScript knowledge base and most importantly, gain a deep understanding of how JavaScript works under the hood. This knowledge can help you create more efficient programs and succeed in job interviews.

If you need to learn JS frameworks like Vue, React, and Angular, a solid knowledge foundation in JavaScript can tremendously accelerate your study.

Throughout the course, you will also learn how to answer questions that are frequently seen in job interviews.

Content highlights:

1. Lecture 1, 2: Everything you need to know about var and let [FREE Preview]

2. Lecture 6: Priority comparison: variable name, function name, and argument name

3. Lecture 9, 10: Higher-order function and currying

4. Lecture 11, 12: Closure and its real-life application [FREE Preview]

5. Lecture 68, 69, 70, 71: The JavaScript prototype chain

6. Lecture 85: two-way data binding

7. Lecture 103: Data structure: Queue, Stack, and Heap  [FREE Preview]

8. Lecture 104: Thread and Process, sync and async, blocking and non-blocking

9. Lecture 105: Recursion and stack overflow

10. Lecture 107: Event loop

11. Lecture 108: Interview challenges: predict the result of the following programs using event loop, macro and micro task queue

12. Lecture 110, 111: tail call optimization

13. Lecture 114, 115, 116, 117: creative inheritance program design

14. Lecture 120, 121: ‘Deep’ copy and assign objects

15. Lecture 122, 123: JavaScript garbage collection, reference count, and the mark-and-sweep algorithm

16. Lecture 124, 125, 126, 127: Basic computing knowledge: bit, byte, memory address, byte addressing, bit width, encoding

17. Lecture 142, 153, 144: Type coercion, wrapper object, explicit and implicit typecasting

18. Lecture 151-163: Bubble sorting

19. Lecture 164, 165: Cocktail sorting

20. Lecture 166, 167: Quick sorting

21. Lecture 168, 169, 170, 171: Counting sorting

22. Lecture 172, 173: Insertion sorting

23. Lecture 174. 175: Bucket sorting

24. Lecture 176, 177: Selection sorting

25. Lecture 178: Time and space complexity and the big O notation

26. Lecture 179, 180: Linear and non-linear data structures: array, linked list, binary search tree, max heap, min heap, etc.

27. Lecture 181, 182, 183, 184: binary heap and heap sorting

28. Lecture 185, 186, 187: the Observer pattern and two-way data binding using the Observer pattern

Please Note:This is NOT a beginner course and does not cover JS DOM and jQuery.

Course Curriculum

Chapter 1: Fill up knowledge loopholes: var, let, const, hoisting, temporal dead zone

Lecture 1: Everything you need to know about VAR

Lecture 2: Everything you need to know about LET

Lecture 3: Constant

Lecture 4: TDZ: Temporal Dead Zone

Lecture 5: Real-life application of LET

Chapter 2: Fill up knowledge loopholes: function hoisting, arguments, caller, callee, THIS

Lecture 1: Who has the highest priority? Variable name, function name or argument name?

Lecture 2: Arguments, caller, callee

Lecture 3: Three ways to redirecting THIS of a funciton

Lecture 4: Higher-order function and currying

Lecture 5: Currying and closure

Chapter 3: Closure and arrow function

Lecture 1: Closure

Lecture 2: Real-life application of Closure

Lecture 3: Syntax of arrow function

Lecture 4: THIS in an arrow function

Lecture 5: Application of arrow function

Chapter 4: Destructure: the fancy way of setting variable values

Lecture 1: Destructure array

Lecture 2: Destructure object

Lecture 3: Destructure string

Lecture 4: Destructure number, boolean, null and undefined

Lecture 5: Destructure function arguments

Chapter 5: ES6 new syntax: Map and Set

Lecture 1: Map basics

Lecture 2: Iterate over MAP using FOR OF

Lecture 3: SET basics

Lecture 4: Application of SET

Chapter 6: ES6 new syntax: Symbol

Lecture 1: Introduction to Symbol

Lecture 2: How to create a Symbol value

Lecture 3: Symbol.for()

Lecture 4: Use Symbol value as the property name

Lecture 5: Well-known Symbol

Chapter 7: ES6 new syntax: Iterator and generator

Lecture 1: The iteration protocol: the iterable protocol and the iterator protocol

Lecture 2: Create your own iterator

Lecture 3: Generator

Lecture 4: Application of generator

Lecture 5: The next() method

Lecture 6: yield *

Chapter 8: ES6 new syntax: Promise

Lecture 1: Introduction to Promise

Lecture 2: The Promise constructor

Lecture 3: The application of Promise

Lecture 4: The then_able object

Lecture 5: Promise.resolve() and Promise.reject()

Lecture 6: Limits of Promise.resolve() and Promise.reject()

Lecture 7: Process several promises together: .all(), .allSettled() and .race()

Chapter 9: ES6 new syntax: async await

Lecture 1: async await

Lecture 2: async await: supplement

Chapter 10: ES6 new syntax: Reflect and Proxy

Lecture 1: Reflect and its methods

Lecture 2: What is Proxy

Lecture 3: Create private properties using the GET trap

Lecture 4: The SET trap

Lecture 5: The has and deleteProperty trap

Lecture 6: Use a proxy object as the prototype

Lecture 7: The defineProperty trap

Lecture 8: The apply trap

Lecture 9: The constructor trap

Lecture 10: Revocable proxy

Lecture 11: Real-life Application

Chapter 11: JSON

Lecture 1: JSON

Chapter 12: CommonJS

Lecture 1: Introduction to CommonJS

Lecture 2: The mechanism of CommonJS: the module object

Lecture 3: Circular dependency

Lecture 4: How CommonJS handles cache: require.cache

Chapter 13: ES6 Module: import export

Lecture 1: ES6 import and export

Lecture 2: How to import

Lecture 3: Named export

Lecture 4: Default export

Lecture 5: The difference between named export and dynamic export: dynamic reference

Lecture 6: Use ESM in browser

Chapter 14: The strict mode

Lecture 1: How to enable the strict mode

Lecture 2: Changes brought by the strict mode

Chapter 15: The Object prototype chain and the prototypal inheritance

Lecture 1: __proto__

Lecture 2: The prototype property of a constructor

Lecture 3: How our own constructor uses the prototype chain

Lecture 4: Real-life application of prototype chain

Chapter 16: The Object Constructor and its methods

Lecture 1: Introduction to the Object constructor

Lecture 2: Object.values(), Object.keys(), Object.entries(), Object.is()

Lecture 3: Object.setPrototypeOf() and Object.assign()

Lecture 4: Object.create() Part 1

Lecture 5: Object.create() Part 2

Lecture 6: Property attributes

Lecture 7: The descriptor object

Lecture 8: Create properties with customized attributes

Lecture 9: Object.preventExtensions()

Lecture 10: Object.seal()

Lecture 11: Object.freeze()

Chapter 17: Accessor and its application: two-way data binding

Instructors

OnlyKiosk Tech
Provide Effective Coding Training

Rating Distribution

1 stars: 2 votes

2 stars: 1 votes

3 stars: 4 votes

4 stars: 36 votes

5 stars: 85 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!