• No products in the cart.

Have you been dabbling with JavaScript but find your files keep turning into a mess of spaghetti code? Do you find yourself copying and pasting lines of code over and over throughout your application? There is a better way, object-oriented programming will allow you to build websites using reusable blocks of code known as libraries. You’ll build a variety of JavaScript objects and explore how their different inheritance models affect your code’s execution and in-memory model.


This course does not involve any written exams. Students need to answer 5 assignment questions to complete the course, the answers will be in the form of written work in pdf or word. Students can write the answers in their own time. Each answer needs to be 200 words (1 Page). Once the answers are submitted, the tutor will check and assess the work.


Edukite courses are free to study. To successfully complete a course you must submit all the assignment of the course as part of assessment. Upon successful completion of a course, you can choose to make your achievement formal by obtaining your Certificate at a cost of £49. Having an Official Edukite Certification is a great way to celebrate and share your success. You can:

  • Add the certificate to your CV or resume and brighten up your career
  • Show it to prove your success

Course Credit: Hack Reactor

Course Curriculum

Introduction 00:01:00
Scopes and Closures 00:01:00
Scopes : An example 00:00:00
Lexical Scope 00:02:00
Scoping Limitations 00:01:00
Calling the Functions 00:01:00
Intro : Execution Contexts 00:01:00
Execution Contexts vs. Lexical Scopes 00:01:00
In-Memory Data Stores 00:02:00
In-Memory Scopes vs In-Memory Objects 00:01:00
Building Multiple Execution Scopes 00:01:00
Intro to Closures 00:01:00
Retaining Access to Functions 00:01:00
Predicting Code Output 00:02:00
Predicting Execution Contexts 00:01:00
Predicting Closure Output 00:01:00
Predicting Closure Output (2) 00:01:00
Predicting Closure Output (3) 00:01:00
Predicting Closure Output (4) 00:01:00
Predicting Closure Output (5) 00:01:00
Predicting Execution Contexts (2) 00:01:00
Predicting Closure Output (6) 00:01:00
Outro 00:01:00
The 'this' Keyword
Intro 00:01:00
Defining the keyword ‘this’ 00:01:00
What is ‘this’ not bound to? 00:03:00
What is ‘this’ bound to? 00:01:00
Predicting Parameter Output 00:01:00
Predicting Parameter Output (2) 00:01:00
Predicting ‘this’ Output 00:01:00
Predicting ‘this’ Output (2) 00:01:00
Predicting ‘this’ Output (3) 00:01:00
Predicting ‘this’ Output (4) 00:01:00
Predicting ‘this’ Output (5) 00:01:00
Deconstructing setTimeout 00:01:00
Predicting ‘this’ Output (6) 00:01:00
Predicting ‘this’ Output (7) 00:01:00
Predicting ‘this’ Output (8) 00:01:00
Predicting ‘this’ Output (9) 00:02:00
Predicting ‘this’ Output with ‘new’ 00:01:00
Outro 00:01:00
Prototype Chains
Prototype Chains 00:01:00
Property Lookup 00:01:00
1-time property copying 00:01:00
Predicting Undefined Property Lookups 00:01:00
Property Lookup on Cloned Objects 00:01:00
Property Lookup of Delegated Objects 00:01:00
The object prototype 00:01:00
Array Prototype 00:01:00
Conclusion – Prototype Chains 00:00:00
Object Decorator Pattern
Code Reuse 00:01:00
Example of Code Reuse 00:01:00
Programming our game 00:03:00
Functions 00:01:00
Benefits of refactoring code 00:01:00
Decorator Functions 00:01:00
Adding Methods to Constructors 00:01:00
Predicting the Value of ‘this’ 00:01:00
Recap of the ‘this’ parameter 00:01:00
Refactoring to Consolidate Code 00:01:00
Predicting Strict Comparison of Objects 00:01:00
Strict Comparison of Returned Functions 00:01:00
Refactoring the .move() Method 00:00:00
Conclusion – Object Decorator Pattern 00:01:00
Functional Classes
Introduction to Classes 00:01:00
Decorator code vs Classes 00:02:00
Reducing duplicity 00:01:00
‘this’ parameter 00:01:00
Functional shared patterns 00:01:00
Adding methods to classes 00:02:00
Property access 00:02:00
Conclusion 00:01:00
Prototypal Classes
Improving Performance 00:01:00
One option for Improving Performace 00:01:00
Delegation Relationships 00:00:00
Constructor Prototypes 00:02:00
How prototypes affect in-memory model 00:01:00
.prototype vs .method 00:02:00
.prototype ambiguity 00:02:00
.prototype.constructor 00:01:00
instanceof operator 00:01:00
Conclusion : Prototypal classes 00:01:00
Pseudoclassical Patterns
Introduction 00:01:00
Constructor Mode 00:02:00
Difference between patterns 00:01:00
Styles of writing classes 00:02:00
Conclusion 00:01:00
Superclass and Subclasses
Introduction 00:01:00
Building Similar Objects 00:01:00
Manually Duplicating Code 00:01:00
Refactoring Into a Superclass 00:01:00
Outro 00:00:00
Pseudoclassical Subclasses
Intro to Pseudoclassical Subclasses 00:01:00
Building Out a Subclass 00:01:00
Incorrect Solutions 00:02:00
‘this’ in Superclass using ‘new’ 00:01:00
‘this’ in Superclass without using ‘new’ 00:02:00
.call()’s First Argument 00:01:00
Using .call() 00:02:00
Subclass Property Prototype Delegation 00:01:00
Constructor Prototype Delegation 00:01:00
Subclass Prototype Delegation 00:03:00
Incorrect Subclass Prototype Delegation 00:02:00
Using Object.create() 00:01:00
Subclass Prototype Constructor Property 00:01:00
Subclass Constructor Delegation 00:01:00
Proper Subclass Constructor Delegation 00:01:00
Psuedoclassical Subclassing Outro 00:01:00
Outro 00:01:00
Submit Your Assignment 00:00:00
Certification 00:00:00

Course Reviews


9 ratings
  • 5 stars0
  • 4 stars0
  • 3 stars0
  • 2 stars0
  • 1 stars0

No Reviews found for this course.

©2021 Edukite. All Rights Resereved
Edukite is A Part Of Ebrahim College, Charity Commission
Reg No 110841