Jump to content
Welcome Guest!

Join us now to get access to all our features. Once registered and logged in, you will be able to create topics, post replies to existing threads, give reputation to your fellow members, get your own private messenger, and so, so much more. It's also quick and totally free, so what are you waiting for?

This site uses cookies! Learn More

This site uses cookies!

For providing our services, we do use cookies.
But get used, this is what most of modern web do!
However we have to warn you since we are obligated to so due to EU laws.

By continuing to use this site, you agree to allow us to store cookies on your computer. :)
And no, we will not eat your computer nor you will be able to eat those cookies :P

Sign in to follow this  

PacktPub Learning Path - JavaScript Patterns (2016)

Recommended Posts


PacktPub: Learning Path - JavaScript Patterns (2016)
WEBRip | English | MP4 | 1280 x 720 | AVC ~449 kbps | 30 fps
AAC | 128 Kbps | 44.1 KHz | 2 channels | 07:50:12 | 3.04 GB

Genre: eLearning Video / Development, Programming

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.
Prerequisites: A firm understanding of JavaScript and JavaScript (ES5) syntax

Resources: Code downloads and errata:

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

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

Learning Object Oriented JavaScript (2h 47m)

Learning JavaScript Data Structures and Algorithms (3h 15m)

JavaScript Design Patterns 20 Patterns for Advancing Your JavaScript Skills (1h 1m)

Mastering JavaScript Design Patterns: A Practical Introduction to Building Better Applications (2h 10m)

JavaScript High Performance (2h 40m)

Table of Contents

Chapter 1 : Learning Object Oriented JavaScript
Setting Up the HTML and CSS
Knowing When the Document is Loaded
Understanding What Objects Are
The Difference between Browsers
Tying Up Loose Ends
Building with Objects
Scoping for Your Scope: 'this' not 'that'
Constructing a Constructor
Reusing Objects
Creating Methods with the Prototype
Augmenting Built-in Objects
Static Properties and Methods
Moving Our Code into a Namespace
Functions that Have Functions
Inheriting Your Parents' Belongings
Creating a Polyfill for Object.create
Overriding Properties and Methods
Creating an Alarm Clock
Turning DIVs into Editable Content in HTML5
Listening to Events
Setting the Alarm Time Dynamically
Dispatching Events
Custom Callbacks
Chapter 2 : Learning JavaScript Data Structures and Algorithms
The Course Overview
What Are Data Structures and Algorithms?
Why Use Data Structures in JavaScript?
Course Format and Datasets Contexts
Introduction to Arrays
Exploring Linked Lists
Introduction to Sets
All about Queues
Exploring Stacks
Introduction to Binary Trees
Exploring Graphs
Describing Algorithms with Big-O Notation
Pathfinding Algorithms
Chapter 3 : JavaScript Design Patterns 20 Patterns for Advancing Your JavaScript Skills
The Course Overview
The Problem with the Global Scope
Moving to One Object and Namespace
The Module Design Pattern
The Module Reveal Pattern
Controlling the Global Access Completely
The Singleton Design Pattern
The Factory Design Pattern
The Abstract Factory Design Pattern
The Builder Design Pattern
The Builder Design Pattern Continued
The Prototype Design Pattern
Abstracting Our Singleton
The Adapter Design Pattern
The Composite Design Pattern
The Decorator Design Pattern
The Fly Weight Design Pattern
The Façade Design Pattern
Getting Things Working Again
The Bridge Design Pattern
The Proxy Design Pattern
The Chain of Responsibility - Part 1
The Chain of Responsibility - Part 2
The Observer Design Pattern - Adding and Dispatching Events
The Observer Design Pattern - Removing Events
The State Design Pattern
Chapter 4 : Mastering JavaScript Design Patterns: A Practical Introduction to Building Better Applications
The Course Overview
Software Design Patterns and Antipatterns
JavaScript Patterns Specifics
Bootstrapping the Project
Adding the Play Functionality
Encapsulating Information
Abstracting Manipulation with DOM Events and Elements
Creating an Adapter to Set Intervals Using Seconds
Using Different Ways to Match Conditions
Modularizing the Application Using Namespaces
Modularizing the Application Using AMD and Require.js
Communication Between Modules
ES6 Modules
Decoupling the Tracks Queue from the Tracks Player
Treating Each Track as a Separate Component
Adding the PubSub Functionality to Tracks
Enabling Track Play and Highlighting the Active Track
Decoupling the Track Model from the View
Formatting Track Time: Two-way Data Binding
Adding a Few Types of Tracks
Implementing Track Removal
Iterating Over Tracks Using a Generator
Iterating Over Tracks Using an Iterator
Adding Nested Tracks and Displaying Them
Fixing the Queue to Work with Nested Tracks
Creating the Server Using Node.js
Returning the Tracks Queue from the Server
Loading Tracks from the Server
Replacing Callbacks with Promises
Binding a Function to a Custom Context
Loading Tracks' Additional Data from the Server
Caching Data Loaded from the Server
Checking for Track Data with a Fallback
Storing Common Tracks Data in Shared Objects
Adding Different Skins for the Player Header
Improving Testability by Inversion of Control
Forcing Function Argument Types
Fixing Models to Support Any String as Attribute Name
Chapter 5 : JavaScript High Performance
Course Overview
Caching Your Scripts
Creating a Cache Buster
Minifying Your Output
Always Declare Your Variables
Creating Location References
Condensing var Definitions
Comparing Explicitly When Appropriate
Using String Accumulator-style
Building Strings with Arrays
Avoiding eval for Object References
Talking to Functions
Avoiding eval
Reducing the Use of Anonymous Functions
OOP - Defining Class Methods and Properties
Picking the Right Loop for the Task
Simplifying Your Loops - Round 1
Reducing the Loop Footprint
Loops, Arrays, and Memory Leaks
Preallocating Size to an Array
Avoiding the Unnecessary
Putting Code Where It Should Be
Clearing Circular References
Using Less Events to Do More
Trading Smoothness for Speed
Clearing Memory Leaks by Always Clearing Intervals
How to Avoid Running Multiple Intervals
Reducing DOM Calls
Reducing Document Reflows
Making It Animate Smoothly
Changing Classes and Not Styles
Adding Scripts as You Need Them Dynamically
Cutting Traveling with HTML5 Validation
Moving Data Processing to the Client Side
What Data Types to Use?
Caching Data
The Issue with Working Directly with HTML Collections
Converting Collection Objects into Arrays
FPS and High Resolution Time - HRT
JavaScript Profiling and Memory Leaks

Buy Premium From My Links To Get Resumable Support,Max Speed & Support Me
Download ( NitroFlare )

[b]Download (Uploadgig)[/b]

Download ( Uploaded

Download ( Rapidgator )

[b]Download (BigFile)[/b]

Share this post

Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

Sign in to follow this