JavaScript Patterns

JavaScript Patterns
JavaScript Patterns
English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 13h 52m | 3.03 GB

Write clear, expressive and maintainable JS

A strong understanding of programming languages helps you to deliver functional solutions quickly, and will reduce your usage of third-party ‘utility’ dependencies like jQuery or lodash. This essential collection of design patterns and best practices will help build your overall understanding of JavaScript as a language, helping you confidently and quickly deliver robust, scalable web applications.

This path navigates across the following products:

  • Learning Object Oriented JavaScript
  • Learning JavaScript Data Structures and Algorithms
  • JavaScript Design Patterns 20 Patterns for Advancing Your JavaScript Skills
  • Mastering JavaScript Design Patterns: A Practical Introduction to Building Better Applications
  • JavaScript High Performance
Table of Contents

Learning Object Oriented JavaScript
001. Setting Up the HTML and CSS
002. Knowing When the Document is Loaded
003. Understanding What Objects Are
004. The Difference between Browsers
005. Tying Up Loose Ends
006. Building with Objects
007. Scoping for Your Scope- ‘this’ not ‘that’
008. Constructing a Constructor
009. Reusing Objects
010. Creating Methods with the Prototype
011. Augmenting Built-in Objects
012. Static Properties and Methods
013. Moving Our Code into a Namespace
014. Functions that Have Functions
015. Inheriting Your Parents- Belongings
016. Creating a Polyfill for Object.create
017. Overriding Properties and Methods
018. Creating an Alarm Clock
019. Turning DIVs into Editable Content in HTML5
020. Listening to Events
021. Setting the Alarm Time Dynamically
022. Dispatching Events
023. Custom Callbacks

Learning JavaScript Data Structures and Algorithms
024. The Course Overview
025. What Are Data Structures and Algorithms
026. Why Use Data Structures in JavaScript
027. Course Format and Datasets Contexts
028. Introduction to Arrays
029. Exploring Linked Lists
030. Introduction to Sets
031. All about Queues
032. Exploring Stacks
033. Introduction to Binary Trees
034. Exploring Graphs
035. Describing Algorithms with Big-O Notation
036. Pathfinding Algorithms
037. Sorting
038. Searching

JavaScript Design Patterns 20 Patterns for Advancing Your JavaScript Skills
039. The Course Overview
040. The Problem with the Global Scope
041. Moving to One Object and Namespace
042. The Module Design Pattern
043. The Module Reveal Pattern
044. Controlling the Global Access Completely
045. The Singleton Design Pattern
046. The Factory Design Pattern
047. The Abstract Factory Design Pattern
048. The Builder Design Pattern
049. The Builder Design Pattern Continued
050. The Prototype Design Pattern
051. Abstracting Our Singleton
052. The Adapter Design Pattern
053. The Composite Design Pattern
054. The Decorator Design Pattern
055. The Fly Weight Design Pattern
056. The Facade Design Pattern
057. Getting Things Working Again
058. The Bridge Design Pattern
059. The Proxy Design Pattern
060. The Chain of Responsibility – Part 1
061. The Chain of Responsibility – Part 2
062. The Observer Design Pattern – Adding and Dispatching Events
063. The Observer Design Pattern – Removing Events
064. The State Design Pattern

Mastering JavaScript Design Patterns: A Practical Introduction to Building Better Applications
065. The Course Overview
066. Software Design Patterns and Antipatterns
067. JavaScript Patterns Specifics
068. Bootstrapping the Project
069. Adding the Play Functionality
070. Encapsulating Information
071. Abstracting Manipulation with DOM Events and Elements
072. Creating an Adapter to Set Intervals Using Seconds
073. Using Different Ways to Match Conditions
074. Modularizing the Application Using Namespaces
075. Modularizing the Application Using AMD and Require.js
076. Communication Between Modules
077. ES6 Modules
078. Decoupling the Tracks Queue from the Tracks Player
079. Treating Each Track as a Separate Component
080. Adding the PubSub Functionality to Tracks
081. Enabling Track Play and Highlighting the Active Track
082. Decoupling the Track Model from the View
083. Formatting Track Time- Two-way Data Binding
084. Adding a Few Types of Tracks
085. Implementing Track Removal
086. Iterating Over Tracks Using a Generator
087. Iterating Over Tracks Using an Iterator
088. Adding Nested Tracks and Displaying Them
089. Fixing the Queue to Work with Nested Tracks
090. Creating the Server Using Node.js
091. Returning the Tracks Queue from the Server
092. Loading Tracks- Additional Data from the Server
092. Loading Tracks from the Server
093. Replacing Callbacks with Promises
094. Binding a Function to a Custom Context
096. Caching Data Loaded from the Server
097. Checking for Track Data with a Fallback
098. Storing Common Tracks Data in Shared Objects
099. Adding Different Skins for the Player Header
100. Improving Testability by Inversion of Control
101. Forcing Function Argument Types
102. Fixing Models to Support Any String as Attribute Name

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

part 1 files 1-18
part 2 files 19-44
part 3 files 45-60
part 4 files 61-84
part 5 files 85-119
part 6 files 120-142