Prototypes - The Ultimate Course On Javascript Prototypes

Master Prototypes, Instantiation Patterns, [[Prototype]], __proto__, and MORE! Become a JavaScript Grandmaster Coder

What you'll learn

Learning prototypes and become a JavaScript grandmaster

Learn what a prototype is, and how to use prototypes to create complex objects

Master the differences between [[Prototype]], __proto__ and the .prototype objects

Learn how to use prototypes to implement inheritance in JavaScript

Learn how to use the power of prototypes in your own code

Learn how to get and set an object’s prototype

Learn how to create your own object constructors

Learn the 5 main ways to create objects in JavaScript

Learn the advantages and disadvantages of prototype-based languages vs classes

Become a PRO JavaScript developer, and earn more money

Learn how to extend existing objects

Learn how to create objects in the most optimal way in JavaScript

Learn the 5 most popular advanced instantiation patterns in JavaScript

Learn how to create object chains using prototypes

Learn why the [[Prototype]] property is hidden

Learn why JavaScript is a prototypal-based language

Learn about hidden properties vs internal slots in JavaScript

Practical examples comparing Java and JavaScript to help you grasp advanced prototype concepts

Learn how to create object chains using composition

Learn the difference between classical-based languages and JavaScript

Learn why __proto__ is partially deprecated by ECMAScript

Learn why __proto__ is referred to as “dunder”

Understand why the .prototype property is on almost every function

Learn why functions in JavaScript are considered to be objects

Understand the different approaches to creating objects in JavaScript

Practical – build objects with multiple levels of prototypes with me

I am here to support you, step-by-step

Have fun mastering web development

From intermediate to expert (advanced +)

You will emerge an expert

Gives you depth of knowledge to boost your ability and confidence

Requirements

Basic JavaScript is recommended

If you don’t know what JavaScript is, you can check out my JavaScript Grandmaster Course

Desire to master object-oriented programming languages

Desire to understand prototypes and JavaScript in more detail

Desire to become a Grandmaster developer

A computer is required as you need to code alongside me to learn effectively

Description

Stop wasting time following so called “developers” that do not practice what they preachALWAYS UPDATED+ Get instant access to 9 hours of high quality videos+ Get access to downloaded resources+ Instructor supportLET ME SHARE MY KNOWLEDGE WITH YOUI’ve been coding for a long time. At the age of 7, in the early 90’s, I got my first pc and a few days later I became an avid gamer. I have always surrounded myself with coders. I remember at 10 years old my cousin managed to hack into a bank’s system. I still recall the days of floppy disks and playing “Doom”, “Duke Nukem” and of course one of my all-time favorites, “Red Alert”. I’ve always been around computers, and that’s what makes my teaching style direct, to-the-point, and powerful!Now, why did I create a course on prototypes?Prototypes are a fundamental concept of JavaScript. They are used to implement inheritance, object creation, and other important features. It is therefore crucial that you understand prototypes – what they are, why they are there, how to use them, how to create them, and when to use them!Understanding JavaScript is ongoing process. To give you a foot up, I’ve structured an all-encompassing, focused course on JavaScript prototypes, which I deliver to you in a way that will benefit you the most. My course teaches you "why" things work and not just "how" to do something mindlessly.What this course covers?It starts at the beginner level of what JavaScript prototypes areIt then goes more in-depth by teaching you how to leverage the power of prototypes to create objects with multiple levels of inheritanceYou’ll learn how to create objects, starting from the basics of object literals to more complex pseudo-classical inheritance patternsLearn the difference between class-based languages (like Java, C#, C++) and prototypal-based languages like JavaScriptLearn the different instantiation patterns, such as functional instantiation, functional-shared, prototypal, pseudo-classical and pure classical Master the differences between [[Prototype]] and __proto__ and the .prototype propertyLiterally this course everything you need to know about prototypes in JavaScript, all in one place :)All the strategies I teach follow timeless coding principles and tactics.WHAT ARE PROTOTYPES?JavaScript was created by a guy called Brendan Eich in the mid-1990s. Eich decided to make JavaScript a prototype-based language because he wanted to create a language that was easy to learn and use. He wanted to create a language that was powerful and flexible, and he believed that prototypes were the best way to achieve this.Prototypes are a powerful feature of JavaScript, because they allow you to reuse code, create complex object hierarchies, and implement inheritance in a simple and efficient way. However, prototypes can also be confusing, and they can make it difficult to understand how JavaScript works.Despite the challenges, the benefits of prototypes outweigh the drawbacks. Q: The million dollar question is "why does learning about prototypes matter?" A: It matters because EVERY object in JavaScript has a [[Prototype]] property. It is this [[Prototype]] property that is often referred to as the “prototype”. By mastering prototypes, you can create complex objects that are extremely memory efficient - improving your website's speed. The prototype itself is also an object … which means that it also has a [[Prototype]] property. Can you begin to see that there’s a prototype “chain” forming? You can think of the prototype chain as a linked list of objects, where each object in the list has a pointer to the next object in the chain.This is the reason why all objects you use and create have inbuilt properties and methods that you can access. This is why:strings have toUpperCase() and toLowerCase()arrays have sort(), map(), push() and filter()numbers have toFixed(), toPrecision(), parseFloat()…You get the idea.Why is learning about prototypes useful?By understanding how prototypes work, how they are created, and how to set them up yourself, you’ll be able to create objects that inherit properties and methods from other objects, without having to explicitly define them.This makes it possible to reuse code and create complex object hierarchies in a simple and efficient way.Can you begin to see how powerful prototypes are and how essential it is today?Knowing the power of how to use prototypes in JavaScript is crucial if you want to become a serious fullstack developer, as it will allow you to build complex data types and web apps.Creating objects can get tricky at times, and I don’t dispute this, but with correct training which includes explaining the fundamentals of prototypes and object creation in a simple way, you will, like me, learn to master and love JavaScript’s dynamic approach to object creation.If you want to become a full stack web developer, you need to know about prototype’s and that’s what this course is all about.WHY IS UNDERSTANDING PROTOTYPES IMPORTANT?JavaScript is built on prototypesTo master JavaScript, you need to master prototypesPrototypes is a way to implement object-oriented programmingPrototypes allow you to extend existing objectsPrototypes allow you to implement inheritance in JavaScriptPrototypes allow you to create custom object constructorsPrototypes allow you to understand the JavaScript engine betterUltimately, by understanding how prototypes work, you can write more efficient and reusable code.After completing this ultimate prototypes course, you will certainly be knowledgeable, confident and able to manage or help others create objects in the most optimal way.WHAT THIS COURSE COVERSThis course is comprehensive, covering the fundamentals of prototypes, composition and class-based languages.Simple enough.The only problem is that in order to truly understand JavaScript, you need to move beyond the basics. That’s why this course covers the basics, and more advanced concepts.First, this course teaches you basics:Learn what prototypes areLearn why everything in JavaScript is considered to be an objectLearn how to set and get an object’s prototypeLearn how to create custom prototypesLearn about the instantiation patterns in JavaScriptUnderstand class instantiation introduce by ECMAScriptMaster the prototype chainLearn about the __proto__ propertyLean about the function’s .prototype propertyUnderstand why everything in JavaScript is considered to be an objectand a whole bunch more!This course also teaches you the advanced concepts:Learn why it’s not good practice to amend the prototype during runtimeWhy you shouldn’t add everything to an object’s prototypeLearn the limitations of prototypesLean the modern ways to get and set an object’s prototypeLearn why __proto__ has been partly deprecate by ECMAScriptUnderstand why the [[Prototype]] is a hidden propertyLearn why the ".prototype" property only matters for constructor functionsPractical example of setting up a prototype chain by using the new keyword, using Object.create() versus setPrototypeOf(), and comparing this to the new class syntaxUnderstand the differences between prototypal languages vs classical languagesUnderstand composition vs prototypesAnd yes, we will code examples in a fun way, and look at how objects work under the hood.## The most comprehensive JavaScript Prototype course on Udemy ##Successful programmers know much more than memorizing a few lines of code. They also know the fundamentals of how a programming langauge works under the hood. Because the JavaScript creators decided to build JavaScript on prototypes, it becomes crucial to understand what prototypes are, how they work, when to use them and why they are so powerful. IS THIS COURSE FOR YOU?Yes. If you fit in any of these categories then this course is perfect for you:#1: BUSY PEOPLE who want to become certified in JavaScript in the shortest time possible.#2: PROGRAMMING DESIRE. You want to advance in the world of programming.#3: FREELANCERS who want to know how successful developers build complicated objects#4: EMPLOYEES who want to gain a solid understanding of why JavaScript is a prototypal-based language and how you can use prototypes in your own projects#5: CODERS who wants to be TOP OF THE GAME.WHY START NOW?Right this second, your competitors are learning how to become better developers.Web development is a blazing hot topic at the moment. But you have a distinct advantage. This course offers memorable learning topics, actionable tactics and real-world examples.Lets get started!MONEY-BACK GUARANTEEI don’t want you to be disappointed.If you don’t like this course for any reason, you can get a full refund in the first 30 days, which is backed by Udemy’s 30-day guarantee, with no questions asked!Invest in yourself today and never look back.Enrol now.

Overview

Section 1: Introduction

Lecture 1 Prototypal Inheritance

Lecture 2 What is JavaScript

Lecture 3 IDE and text editors

Lecture 4 All objects have a [[Prototype]]

Lecture 5 All objects have a prototype

Lecture 6 There are different [[Prototype]] objects

Lecture 7 Functions are special

Lecture 8 Why objects and prototypes are so important

Lecture 9 In JavaScript, objects rule the roost

Lecture 10 JavaScript is an object oriented programming language

Lecture 11 Hypothetical project example

Lecture 12 Use prototypes when creating objects with a similar type

Section 2: The [[Prototype]] object

Lecture 13 Section intro

Lecture 14 Why understanding prototypes matter

Lecture 15 All objects have a [[Prototype]] property

Lecture 16 The [[Prototype]] is hidden

Lecture 17 Why is the [[Prototype]] an internal property

Lecture 18 Hidden Property vs Internal Property vs Internal Slot

Lecture 19 Getting and setting prototypes

Lecture 20 Almost everything in JavaScript inherits from the Object interface

Lecture 21 Primitive data types have no direct prototype

Lecture 22 Is null a primitive or object?

Lecture 23 Primitive values and object wrappers

Lecture 24 Bottom line: primitives are not objects, but indirectly inherit from the Object

Lecture 25 Creating an object "primitive", using a constructor

Lecture 26 Primitives - taking a step back

Lecture 27 Creating a custom [[Prototype]]

Lecture 28 Setting prototypes

Lecture 29 Setting prototypes example

Lecture 30 The prototype of an object literal will point to its constructor's ".prototype"

Lecture 31 Developers jargon

Lecture 32 Inherited methods

Lecture 33 The prototype chain

Lecture 34 A prototype chain example

Lecture 35 The prototype will eventually point to null

Lecture 36 A quick recap on [[Prototype]]

Lecture 37 The prototype has limitations

Lecture 38 Shadowing inherited properties and methods

Lecture 39 Shadowing summary

Lecture 40 The prototype does not affect the value of THIS

Lecture 41 Looping through objects

Lecture 42 Enumerable properties

Lecture 43 Iterating methods

Lecture 44 Warning - don't change the prototype on the fly

Lecture 45 Warning - don't mess with in-built prototype objects

Lecture 46 I am only talking about pure objects

Lecture 47 Modifying the prototypes of built-in objects

Lecture 48 Summary

Section 3: Instantiation Patterns

Lecture 49 Section intro

Lecture 50 Object Literals

Lecture 51 This section is crucial

Lecture 52 Instantiation Patterns

Lecture 53 Instantiation patterns you'll be learning about in this section

Lecture 54 Functional Instantiation

Lecture 55 Shortcomings of functional instantiation

Lecture 56 Functional Instantiation - closing comments

Lecture 57 Functional Shared Instantiation

Lecture 58 Functional Shared instantiation - closing comments

Lecture 59 Prototypal Instantiation - Introduction

Lecture 60 Object.create()

Lecture 61 Prototypal Instantiation - example

Lecture 62 Prototypal Instantiation - explained

Lecture 63 Prototypal Instantiation - closing comments

Lecture 64 Pseudoclassical Instantiation - intro

Lecture 65 Pseudoclassical Instantiation - example

Lecture 66 Pseudoclassical Instantiation - closing comments

Lecture 67 Warning: you can't add everything to the prototype

Lecture 68 Combining inheritance and constructors

Lecture 69 Arrow syntax cannot be used as a constructor

Lecture 70 Arrow syntax has no binding of THIS

Lecture 71 Class Instantiation

Lecture 72 Class Instantiation - closing comments

Lecture 73 Code

Lecture 74 BAM, POW - you've done it!

Section 4: Prototypes and Instantiation Patterns - Test

Section 5: __proto__ (aka: dunder proto)

Lecture 75 Section intro

Lecture 76 __proto__ introduction

Lecture 77 What is ECMAScript and how was __proto__ introduced?

Lecture 78 Let's define our own __proto__ getter and setter

Lecture 79 How to pronounce __proto__?

Lecture 80 Dunder proto is not an internal property

Lecture 81 Tennis Analogy

Lecture 82 __proto__ is partly deprecated, in Annex B

Lecture 83 Modern alternatives to getting & setting an object's prototype

Lecture 84 When should you use setPrototypeOf()

Lecture 85 Take a step back

Lecture 86 Problem #1. __proto__ is easily configurable

Lecture 87 Problem #2. __proto__ is a special keyword

Lecture 88 Setting an object's prototype to null

Lecture 89 My overall thoughts on dunder proto

Lecture 90 MDN's warning

Lecture 91 Summary of __proto__

Lecture 92 Hang the Dunder on the wall

Section 6: The .prototype property

Lecture 93 Only functions have a .prototype property

Lecture 94 Some functions do not have a .prototype property

Lecture 95 Why developers get confused with the word "prototype"

Lecture 96 [[Prototype]] is not the same as the prototype

Lecture 97 The .prototype only matters for constructor functions

Lecture 98 There are exceptions to the rule

Lecture 99 A constructor function is defined by the [[Call]] and [[Construct]] properties

Lecture 100 The .prototype property is an object

Lecture 101 The object's [[Prototype]] is assigned to the functions .prototype

Lecture 102 Almost all functions have both a [[Prototype]] and .prototype property

Lecture 103 Why is the Function's .prototype property a function and not an object?

Lecture 104 Functions in JavaScript are also objects

Lecture 105 There are multiple prototypes in the chain

Lecture 106 What is the constructor property?

Lecture 107 A fun test

Lecture 108 The .prototype property can be overwritten

Lecture 109 The entire prototype chain revealed

Lecture 110 The Object.prototype rules the roost

Lecture 111 Differences between [[Prototype]] and .prototype

Lecture 112 [[Prototype]] and .prototype serve two different purposes

Lecture 113 Summary of the .prototype property

Lecture 114 Functions have a .prototype property

Section 7: Practical Application - building your own prototype chains

Lecture 115 Course project overview

Lecture 116 Using the 'new' keyword to set up a prototype chain (prior to 2011)

Lecture 117 Creating the prototypal chain using the 'new' keyword

Lecture 118 The problems with using the 'new' keyword

Lecture 119 Fixing the constructor reference problem

Lecture 120 Using Object.create() to set up a prototype chain (after ES5 - 2011)

Lecture 121 Using Object.create() is still not ideal

Lecture 122 Using Object.setPrototypeOf() to set up a prototype chain (after ES6 - 2015)

Lecture 123 Using Classes to set up a prototype chain (after ES6 - 2015)

Lecture 124 Using the "extends" keyword to build our class-based prototype chain

Lecture 125 Building a 3 level custom prototype chain - using Constructor Functions

Lecture 126 Building a 3 level custom prototype chain - using Classes

Lecture 127 Problems with our code - duplication

Lecture 128 Solution: using the call() method with constructor functions

Lecture 129 Completing 3 levels of prototype inheritance - Constructor Functions

Lecture 130 Completing 3 levels of prototype inheritance - Class Syntax

Lecture 131 Summary

Lecture 132 Adding more levels and siblings

Lecture 133 You've beaten prototypes

Section 8: Prototypal languages vs Classical languages

Lecture 134 What is an OOP language and how do classes and prototypes fit into the picture?

Lecture 135 How class-based languages and prototype-based languages deal with inheritance

Lecture 136 Hello World example - classes vs prototypes

Lecture 137 Java Console vs JavaScript Console

Lecture 138 Inheritance code with Java (a class-based language)

Lecture 139 Testing code on JDoodle

Lecture 140 Comparison between classes and prototypes

Lecture 141 Section Summary

Lecture 142 Use this knowledge

Section 9: Prototypes vs Composition

Lecture 143 Intro into composition

Lecture 144 Composition code - converting our prototypal-based model, to composition

Lecture 145 Inheritance vs Composition - summary

Lecture 146 Summary - when to use composition vs prototypes

Section 10: Outro

Lecture 147 Outro

Anyone interested in learning the art and science behind JavaScript prototypes,BUSY PEOPLE who want to become certified and confident about what “prototypes” mean in the shortest time possible,Freelancers who want to learn how to become an effective JavaScript developer,Anyone who has completed my JavaScript Complete Grandmaster course,YES: This course is for intermediates. It’s aimed at people who have some knowledge of JavaScript, but want to dig deeper,NO: This course is NOT only for intermediate beginners. It is a complete course that goes from basics to advanced.,YES: This course is for someone wanting to be a professional, to be expert and confident in knowing how to create objects and structure their code,Those who want to learn modern coding without third party libraries and frameworks,Those interested in building their own frameworks, or being better able to learn from the source code of other well-known frameworks and libraries,Those who have some knowledge of OOP-based languages and JavaScript, but little knowledge about how prototype inheritance works behind the scenes, and how to practically implement best practices in their websites