The Hard Parts of Object Oriented JavaScript
Learning Paths:
Topics:
Table of Contents
Introduction
Course Introduction
Will Sentance introduces the ideology of the course, what makes a great software engineer, Codesmith, and how to get the most out of what is taught.
Object Oriented Paradigm
Will gives an overview of what will be taught and then answers why a paradigm, or way of organizing code, exists at all.
Object Creation
Creating an Object
Will starts by establishing objects as the best method to encapsulate data and functionality.
Object dot Notations
The basic way to assign data to an existing object is introduced.
Object.create
Will uses Object.create to start a conversation about the DRY principle.
Creating Objects with Functions
Will diagrams solution 1, a function that returns an object when initiated. It's then explained why the solution wouldn't work in practice.
Prototype & new
Avoid Duplication with Prototype
Will introduces the next problem to be solved, which is refactoring the previous solution into one that uses object.create to create objects, but still has access to the functionality.
Prototype Walkthrough
Will diagrams solution 2 using Object.create and prototype chaining with input from the audience.
Prototype Chain
Will traces the diagramed solution using increment() on the instantiated user1, demonstrating how JavaScript accesses the function. Lessons are taken away from the solution that impacts the way we consider object oriented programming in JavaScript
new & this Keywords
Will introduces the `new` keyword and what it automates in object creation, but also how it instantiates the need to refer to it.
Functions are Objects & Functions
Will maps out the object that gets attached to each instantiated function, and what it contains.
new Keyword & Share Functions with prototype
Will diagrams solution 3 using the new keyword and prototype chaining with input from the audience.
Review of new
Will speaks to the benefits and disadvantages that solution 3 has, and topics covered later are foreshadowed.
Scope & this
Calling Prototype Methods
Will refactors solution 3 to include the implicit parameter, this. As the solution is diagramed, attention is given to when this is useful, and how scope comes into play.
this Keyword Scoping Issues
The UserCreator.prototype.increment function is refactored further, and this poses an interesting problem with scope.
Solving Scope with Arrow Functions
Will diagrams how arrow functions bypass the issue introduced in the previous section.
ES6 class Keyword
WIll introduces how JavaScript implements class syntactic sugar.
Recap of the class Keyword
Will explains how classes in JavaScript are much different than in true OOP languages, and ties the previous sections into the next section of the course.
Default Prototype Chain
Objects default __proto__
Will uses an example to further explain how __proto__ is built into every object in JavaScript. In addition to __proto__, hasOwnProperty is a built-in method that has bonus functionality afforded to it.
Function.prototype and Array.prototype
WIll diagrams the prototype chain when calling a method on a function.
Pair Programming OOJS
Will directs students to the practice problems and sets up pair programming.
Subclassing with Factory Functions
Intro to Subclassing and Inheritance
Will introduces inheritance as a way to create subclasses within JavaScript and explains why inheritance is a misleading term.
Create object with Factory Function
Solution 3 is further refactored to implement classes. Will traverses the code with the audience.
Create a Sub-Factory Function
Will sets up the next bit of code and explains how this code is interacting with the code that was written in the previous segment. Object.setPrototypeOf is utilized to set the __proto__ of a function to achieve the functionality that we need.
Creating an object with a Sub-Factory Function
Will continues to diagram the solution and demonstrates how the sub-factory function affects the functionality of an object that is instantiated.
Prototype Lookup
Will concludes this solution by diagramming a prototype lookup by an object that was previously instantiated.
Subclass Review
Will reviews what was learned up until now in the course, and looks towards the call and apply functions that will be introduced to control the assignment of the this keyword.
Call and Apply
WIll demonstrates how to manually set the value of the this keyword inside of a function.
Subclassing with new and call
Create an Object with new
Will diagrams a refactored solution that provides the store of automatically linked functions by utilizing the new keyword.
Creating a Subclass with a Constructor
WIll diagrams a solution that uses the new keyword, but then also uses a prototype chain to grant an object access to certain classes, while another doesn't.
Using a call Method in a Constructor
By passing our newPaidUser object (`this`) to userCreator, Will demonstrates how this can refer to a context that is one level up from the current scope.
Assigning Properties to Instance
Will diagrams how instantiating a paidUser object using the new keyword would create a new context to consider.
Prototype Tracing
Will traces the diagramed solution using called functions on the instantiated paidUser, ensuring that functions are specific to the paid user type, but are available to all users.
Subclassing with class, extends & super
Create an Object with a class
WIll diagrams a user object that is instantiated using the new keyword. No functions are copied on it, but they are still available for use.
Creating a Subclass with extends
Will introduces the extends, and diagrams what it offers to the refactored code.
Creating an object with a subclass
The last execution context of the course is instantiated, and a paidUser is created using the new keyword. Will also briefly covers reflect.construct(), which acts like the new keyword, but as a function.
Using super in a subclass constructor
Will arrives at the final solution, where a paidUser1 has access to paidUser functionality, and user functionality. The paidUser1 also has the properties of a regular user by using the regular userCreator.
