Next Level JavaScript: Upgrade your JavaScript skills to ES6 and beyond

Next Level JavaScript: Upgrade your JavaScript skills to ES6 and beyond
Next Level JavaScript: Upgrade your JavaScript skills to ES6 and beyond
English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 16h 39m | 3.75 GB

Great JavaScript is more than just syntax or style guides. This Learning Path starts by leading you through advanced JavaScript concepts, swiftly moving on to showing you how you can use ES6 and functional programming right away in live projects and applications.

This path navigates across the following products (in sequential order):

  • Mastering JavaScript (4h 10m)
  • JavaScript Design Patterns (3h 15m)
  • Learning JavaScript Promises (2h 37m)
  • Learning Functional JavaScript (2h)
  • JavaScript High Performance (2h 40m)
Table of Contents

Mastering JavaScript
1.Using White Space for Readability
2.Declaring Variables
3.Declaring Complex Data Types and Functions
4.OOP Naming Conventions
5.Creating a Global Namespace
6.Constants (and Pseudo constants)
7.Smart Coercion of Data Fields
8.Targeting at JavaScript Versions or Features
9.Creating an onload Method That Always Works
10.OnReady – Our First Cross-browser Script
11.Using Modernizr to Detect Features
12.Building a Conditional Logic Flow
13.Selecting DOM Elements Natively in HTML5
14.Creating a Cross-browser Script Loader
15.Using Sizzle to Select DOM Elements
16.Defining a Namespace
17.Creating Private Variables in JavaScript
18.The JavaScript Module Design Pattern
19.Version Controlling Our Library
20.Building Out Our Library
21.Thinking with Interfaces
22.Creating an Adapter Design Pattern
23.Building a jQuery Adapter
24.Adding a Functionality Method
25.Mimicking the jQuery Wrapper
26.Introducing the Facade Design Pattern
27.Creating a Facade Creator
28.Creating a New Global Function Through the Facade
29.Creating an Advanced Facade Pattern
30.Creating a Singleton
31.Building the Constructor for Our Ticker
32.Connecting Time with Our Ticker
33.Processing Interval groups
34.Exposing Our Ticker to the World
35.Creating an Event Dispatcher
36.Integrating the Event Dispatcher into Our Library
37.Removing Events from the Dispatcher
38.Building Test Units

JavaScript Design Patterns 20 Patterns for Advancing Your JavaScript Skills
39.The Problem with the Global Scope
40.Moving to One Object and Namespace
41.The Module Design Pattern
42.The Module Reveal Pattern
43.Controlling the Global Access Completely
44.The Singleton Design Pattern
45.The Factory Design Pattern
46.The Abstract Factory Design Pattern
47.The Builder Design Pattern
48.The Builder Design Pattern Continued
49.The Prototype Design Pattern
50.Abstracting Our Singleton
51.The Adapter Design Pattern
52.The Composite Design Pattern
53.The Decorator Design Pattern
54.The Fly Weight Design Pattern
55.The Facade Design Pattern
56.Getting Things Working Again
57.The Bridge Design Pattern
58.The Proxy Design Pattern
59.The Chain of Responsibility – Part 1
60.The Chain of Responsibility – Part 2
61.The Observer Design Pattern – Adding and Dispatching Events
62.The Observer Design Pattern – Removing Events
63.The State Design Pattern

Learning JavaScript Promises: Practical Applications in ES6 and AngularJS
64.Promises – You-ve Been Using Them All Along
65.Make Me a Promise
66.Creating ES6 Promises
67.There Are Only Two Types of Promises in This World
68.Deciding What’s Next
69.No Second Chance
70.Callbacks Execution and Timing
71.The Future Is Coming – Angular v2 Promises
72.Chaining Promises
73.Making API Data User-ready
74.Changing Successes into Failure
75.Turning Failure into Success
76.Parallel and Independent Tasks
77.Interdependent Tasks
78.Series Flow – with a Twist
79.Make It All Asynchronous
80.The Pitfall of No Return
81.Promises Versus Events
82.Race to the Finish Line

Introduction to Functional Programming
83.The Course Overview
84.What Is Functional Programming-
85.Your First Functional Programming Concepts
86.First-class Functions
87.Passing Functions as Arguments
88.Returning Functions
89.Callbacks
90.Continuation Passing Style
91.Promises
92.Partial Function Application
93.Currying
94.Composition
95.What Is Immutability-
96.Working with Immutability
97.Immutability in the UI
98.Mechanics and Performance
99.Recursive Thinking
100.A Recursive AST Parser
101.Trampolining
102.Lazy Evaluation
103.Lazy Sequences
104.Infinite Sequences
105.Caching Your Scripts

JavaScript High Performance
105.Course Overview
106.Creating a Cache Buster
107.Minifying Your Output
108.Always Declare Your Variables
109.Creating Location References
110.Condensing var Definitions
111.Comparing Explicitly When Appropriate
112.Using String Accumulator-style
113.Building Strings with Arrays
114.Avoiding eval for Object References
115.Talking to Functions
116.Avoiding eval
117.Reducing the Use of Anonymous Functions
118.OOP – Defining Class Methods and Properties
119.Picking the Right Loop for the Task
120.Simplifying Your Loops – Round 1
121.Reducing the Loop Footprint
122.Loops, Arrays, and Memory Leaks
123.Preallocating Size to an Array
124.Avoiding the Unnecessary
125.Putting Code Where It Should Be
126.Clearing Circular References
127.Using Less Events to Do More
128.Trading Smoothness for Speed
129.Clearing Memory Leaks by Always Clearing Intervals
130.How to Avoid Running Multiple Intervals
131.Reducing DOM Calls
132.Reducing Document Reflows
133.Making It Animate Smoothly
134.Changing Classes and Not Styles
135.Adding Scripts as You Need Them Dynamically
136.Cutting Traveling with HTML5 Validation
137.Moving Data Processing to the Client Side
138.What Data Types to Use?
139.Caching Data
140.The Issue with Working Directly with HTML Collections
141.Converting Collection Objects into Arrays
142.FPS and High Resolution Time – HRT
143.JavaScript Profiling and Memory Leaks

part-1 files 1-24
part-2 files 25-38
part-3 files 39-51
part-4 files 52-67
part-5 files 68-81
part-6 files 82-105
part-7 files 106-131
part-8 files 132-144