Advanced and Object Oriented JavaScript and ES6

Explore how JavaScript achieves object-oriented programming through objects and inbuilt types, master primitive and reference types, and learn how properties can be added or removed to emulate classes.

Explore JavaScript primitive types - number, string, boolean, null, and undefined - and how strings can represent a single character, while uninitialized primitives default to undefined.

Explore JavaScript primitive types by declaring variables (string, number, boolean, object, null, undefined) with var, and print them to the browser using a script block.

Learn how primitive types store values directly in variables, and how assigning one variable to another creates an independent copy, unlike objects which use references.

Use the typeof operator in JavaScript to determine a variable's runtime type. Observe string, number, and boolean types, and note null appears as an object.

Explore how the === operator compares type and value to reliably detect null in JavaScript, avoiding type coercion. See how == differs by converting types.

Explore how primitive types in JavaScript—strings, numbers, and booleans—expose versatile methods, such as toLowerCase, substring, charAt, and toString, enabling string manipulation and type conversion.

Explore reference types in JavaScript by creating objects with properties (names and values), using built-in reference types to model classes, instances, and methods.

Create a JavaScript object using the generic Object type and the new operator, then show dynamic property additions and how reference types share memory locations.

Explore inbuilt reference types in JavaScript, including arrays, dates, errors, functions, and regular expressions, and learn how to instantiate them with new for practical use cases.

Explore object literals in JavaScript by creating a student object with braces and key-value pairs, contrasting literal forms with the new operator and accessing properties via document.write.

Define arrays using literal syntax with square brackets and values like John, Bob, and Harry. Compare array literals to the constructor form new Array(...), and access elements by zero-based indices.

Prefer function literals to the Function constructor for creating functions, because literals are simpler, more readable, and better supported by debuggers, while the new Function constructor is rare and confusing.

Explore regular expression literals in JavaScript by writing a regex between forward slashes, including patterns like \d+, and compare literal creation with the constructor, highlighting escape rules and developer preferences.

Use the instanceof operator to identify exact reference types at runtime for objects like a student, an array of student names, and a function.

Learn how JavaScript uses wrapper types for primitive types like string, number, and boolean, and why the engine creates and destroys these temporary objects; avoid using them directly in code.

Learn why you should avoid using JavaScript wrapper types and rely on primitive types, and how the engine creates and destroys inbuilt objects, with typeof and instanceof checks.

Master primitive types in JavaScript—strings, numbers, booleans, null, and undefined—and use typeof to check types; create and access objects with new or literal syntax, and use instanceof for reference types.

Explore how functions in JavaScript are objects with a call property. Learn to create functions with different syntaxes, pass dynamic parameters, overload, and use this when invoking on an object.

Explore function declaration and function expression in JavaScript, including named and unnamed functions. Compare their syntax, invocation, and how they determine even or odd results.

Explore function hoisting by comparing function declarations and function expressions, showing how declarations are hoisted to the top of their scope while expressions are not, with examples and errors.

Learn how to pass a function as a parameter to an array method in JavaScript, using an anonymous function to sort numbers correctly with num1 minus num2.

Learn how JavaScript functions can accept any number of arguments using the arguments object, access them by index, and inspect length and named parameters with function.length.

Learn to implement a product function that uses the arguments object to multiply any number of inputs, including none, and returns the resulting product.

JavaScript lacks true function overloading; the last function with the same name overrides earlier ones, so three arguments yield 5 instead of 9.

Implement function overloading in javascript by using the arguments array to conditionally execute different logic based on its length within a single function.

Create objects using literal syntax and assign properties, then add a display method with a function expression. Access properties, invoke the method, and debug syntax issues via the browser console.

Use the this object to access id and name, decoupling methods from a single student instance for reuse across student objects.

Reuse a function across objects by assigning it as a property, so Student 1 and Student 2 can display details using this in their respective objects.

learn how the call method sets this to an object, enabling function reuse across objects, and compare with apply and bind to control this and arguments in object oriented javascript.

Explore the apply method, which mirrors call but accepts an array of arguments, and see how to pass test scores and parameters dynamically.

Explore how the bind method differs from call and apply, dynamically binding an object to a method and returning a bound function for details display.

Explore declaration and expression function creation, and master function hoisting and that functions are objects. Use arguments and arguments.length with call, apply, and bind to control this and address overloading.

Master dynamic JavaScript objects by adding, deleting, and reading properties, and defining accessor properties for encapsulation. Explore property attributes to control access and how to freeze objects.

Explore how JavaScript creates objects with literal form or the new operator, and how adding properties uses the put method, while modifying properties uses the set method and allocates memory.

Learn how to use the in operator to check at runtime whether a property exists on an object, including properties that point to functions, with results seen in the console.

Learn how to distinguish owned properties from inherited ones with hasOwnProperty in JavaScript. Compare it with the in operator and understand when to check ownership versus inheritance.

Use the delete operator to remove a property from a JavaScript object, which behaves like a hash table, returning true when deletion succeeds and false when deletion cannot be performed.

Learn to retrieve enumerable properties of a JavaScript object by iterating with a for-in loop, then access each property's value via square bracket notation and console.log.

Discover how to check property enumerability in JavaScript with the propertyIsEnumerable method, noting that user object properties are enumerable while many built-in properties, like array length, are not.

Learn to protect object data with accessor properties in JavaScript, using getters and setters to control read and write access. Explore the underscore private convention and a credit card example.

Explore how JavaScript object property attributes govern visibility and access, focusing on enumerable and configurable flags, using Object.defineProperty to create non-enumerable data properties and understand ES5 enhancements.

Explore how the configurable attribute governs whether data and accessor properties can be modified or deleted, with false preventing changes, deletion failing silently, and non-configurable blocking redefinition in strict mode.

Explore data property attributes by using Object.defineProperty to add a name to a credit card object and understand how value, writable, enumerable, and configurable control mutability, visibility, and deletion.

Learn to define accessor property attributes with Object.defineProperty using get and set descriptors, enabling dynamic, non-intrusive access to existing objects, with enumerable and configurable options.

Adjust enumerability, configurability, and writability of accessor properties by removing enumerable, configurable, getter, or setter attributes. Test changes with console logs, delete attempts, and property writes to observe outcomes.

Define multiple properties at once using Object.defineProperties, supplying an object of properties—data and accessor—each with attributes like enumerable, configurable, and writable, updating or adding properties on the target object.

Identify how to retrieve and inspect a property's attributes with Object.getOwnPropertyDescriptor, showing enumerable, configurable, writable, and value. Compare default booleans true when created normally to false with defined property syntax.

Learn how the extensible attribute makes objects able to gain new properties, and how Object.preventExtensions, sealing, and freezing render them non-extensible. See non-strict mode fail silently and strict mode raise errors.

Seal an object to make it non-extensible and all its properties non-configurable, preventing additions, deletions, or reconfigurations; use Object.seal and verify with isExtensible, isSealed, and getOwnPropertyDescriptor.

Learn how to freeze objects to make them non-extensible and read-only, using Object.freeze and Object.isFrozen to enforce immutability and verify the state.

Manage JavaScript objects by adding or removing properties and checking with in. Define properties with Object.defineProperties, enumerate keys, and learn data and accessor attributes plus prevent extensions, seal, and freeze.

Use constructor functions, named with a capital letter, to create objects via the new operator and share properties and methods. Verify an object's type with instanceof or the constructor property.

Define a constructor to create objects with shared properties and a display method; add airlines and flight number properties assigned by parameters, enabling multiple parametrized flight instances.

Two points: you can explicitly return an object from a constructor (primitives are ignored), and you can define properties, accessors, and attributes inside the constructor so all instances share them.

Discover how prototypes power JavaScript objects by using a function's prototype to share methods across instances, enabling memory efficiency and prototype chaining for inheritance.

Explore how built-in prototypes power shared methods like hasOwnProperty and toString across objects, and define custom prototypes on constructors to reuse properties and behaviors in JavaScript.

Learn how to inspect an object's prototype using Object.getPrototypeOf and isPrototypeOf, compare it to the constructor's prototype, and verify prototype relationships in JavaScript.

Explore how the JavaScript engine resolves properties by checking an object's own properties first, then its prototype, using toString as an example, and returning undefined when not found.

Learn to move the display function from the flight constructor to its prototype property, enabling shared methods and memory efficiency for all flight objects created from the constructor.

Learn how to add multiple prototype properties at once with an object literal, defining functions and data properties together, including a toString that returns flight details.

Define the constructor property on a prototype when using literal syntax to ensure objects report the correct constructor during instance checks, and place it at top to keep comparisons reliable.

Explore how to use built-in object prototypes to add new properties and methods, focusing on string prototype, wrapper types, and safe, cautious use in JavaScript.

Learn how constructors create multiple objects with identical properties and how instanceof verifies them. Discover the prototype's shared properties, prototype checks, and how inheritance flows from prototype.

Explore implicit inheritance by using object literals and observing how properties come from the prototype rather than own properties. Verify with Object.getPrototypeOf that the prototype equals Object.prototype, showing inherited methods.

Create objects explicitly with Object.create by supplying a prototype and a second parameter of property descriptors (configurable, enumerable, writable, value) to enable inheritance from another object's prototype.

Explore your own object inheritance in JavaScript by creating project 1 and project 2, using object.create, prototype chaining, and property shadowing with a shared display function.

Learn constructor inheritance in JavaScript by creating doctor and surgeon constructors, extending doctor via the surgeon prototype, overriding toString, and implementing a treat method for patient care.

this lecture demonstrates constructor inheritance in action by creating a doctor and a dental surgeon. it shows the surgeon inherits the doctor's treat method and compares tostring outputs; instanceof checks.

Learn how to access supertype constructors in JavaScript by invoking the parent constructor with ParentConstructor.call(this, ...), ensuring inherited properties initialize correctly when needed.

Learn to override and shadow parent methods in JavaScript, reuse parent logic with Doctor.prototype.treat, and call parent functions to handle treating before operating.

Explore inheritance in JavaScript by prototype chaining and constructor-based patterns, using prototype properties and the call method to invoke parent constructors, and override parent methods from child objects.

Learn the module pattern with an immediately invoked function expression (IIFE) to create private variables and expose public methods through a returned object, achieving encapsulation.

Implement the module pattern with an IIFE to create a private balance and a public account object, exposing get balance and add interest methods while hiding internal state.

Explore es6 features like block scope with let and const, template strings with substitution, destructuring for objects and arrays, for-of, maps and sets, classes with inheritance, and modules with export-import.

Explore how ES6 introduces block scope with let, contrasting it with var's function or global scope, and learn hoisting and scope behavior in for loops.

Explore template strings for multi-line text without concatenation, using the backtick operator, ES6 template literals, and a console log showing formatted output.

Learn how to perform variable substitution in template strings using placeholders like ${name}. Define a name variable and observe dynamic replacement update the value in the displayed text.

Master arrow functions to create anonymous functions with concise syntax, assign them to variables, and pass them as callbacks, with implicit returns or explicit returns when using brackets.

Master creating your first arrow function with the fat arrow syntax, assign it to a variable, and invoke it to display a hello message in the console in ES6.

Learn how to pass parameters to an arrow function by defining arguments and returning results, with examples adding and dividing two numbers.