Módulo 1: Classless objects
- Creating individual objects (basic way to create object using literals)
- Object properties (adding, modifying and deleting properties, nested properties )
- Dot notation vs. bracket notation (dot notation as the primary way to refer to object fields, use of bracket notation to allow the use of multi-word and computed keys)
- Property existence test and property enumeration (test for the presence of a field in an object, using the for … in to pass the keys of an object, the Object.key method as an alternative to for … in)
- Comparing objects (the idea of object references, reference comparison vs. field comparison – deep comparison)
- Coping objects (coping references, cloning, merging – Object.assign method; spread operator and shallow cloning, deep cloning concept)
- Methods (function as an object property, define methods in the object body and add methods to existing objects, using this keyword inside of methods)
- Getters and setters (methods treated as properties – defining and using getters and setters)
- Property and object configuration (modifying attributes of objects and fields; using methods Object.defineProperty, Object.preventExtensions, Object.seal and Object.freeze)
- Different ways to create classless objects (factories, constructor function and new operator, Object.create method)
- Prototypes (prototype-based inheritance, object property __proto__, constructor function prototype property, use of setPrototypeOf method)
Módulo 2: Classes and class-based approach
- Class declaration (normal class declaration – keyword class; class body – constructor, properties, methods; class as first-class citizen – storing classes in variables and class expression)
- Creating objects from a class (creation of an object based on a class; looking for a connection between an object and a source class – instanceof operator)
- Properties (properties definition inside of class methods – constructor and regular methods; direct declaration inside of the class body)
- Getters and setters (defining and using getters and setters)
- Inheritance (class inheritance – extends keyword; shadowing methods and properties; using the super keyword in the constructor and in methods)
- Static members (the concept of static members; methods and properties associated with a class instead of an object – defining and using)
- Classes vs constructors (similarity of classes to constructors; conversion of a class into an adequate constructor function and vice versa)
Módulo 3: Built-in objects
- Number constructor (number constructor – creating Number objects from data of different types, including various string formats; converting numbers into different string formats; static properties and methods of the Number constructor, i.e. properties defining the basic ranges)
- String constructor (String constructor; string as an array of characters; case conversion methods; splitting the string; searching for and replacing substrings; padding and trimming; comparison of strings)
- Date constructor (creating Date object – constructor; time zones and local time handling; getting current time; timestamp and using it to measure the time of code execution; time specification; operating on individual date and time components)
- Array – basics (basic methods for managing an Array type collection – creating, merging, adding and removing items, passing through, slice method, splice method; use of spread operator; destructuring assignment)
- Array – advanced methods (the functional approach: find, every, some, filter, sort, map and reduce)
- Set type collection (concept of set data structure and Set object; basic methods and properties of Set objects – constructor, add, has, delete, clear, size; walking through elements – for … of, iterators; spread operator)
- Map type collection (concept of map data structure and Map object; basic methods and properties of Map objects – constructor, set, get, has, delete, clear, size; walking through elements – for … of, iterators; spread operator)
- Object as a data structure (using the object as a regular dictionary-type data structure; items management, walking through, spread operator)
- Using the JSON object (basic concept of JSON /JavaScript Object Notation/ format; converting data to JSON – JSON.stringify method; parsing JSON format and obtaining data back – JSON.parse method)
- Using the Math object (basic methods: ceil, floor, round, random, min, max, abs, pow, log, trigonometric functions)
- Using the RegExp object (basic rules for creating regular expressions; abbreviated notation of a RegExp object declaration; using methods of RegExp and String objects for efficient searching of patterns in text: test, exec, match, search, replace)
- Extending built-in types (using prototypes to extend built-in types – adding new properties and methods)
Módulo 4: Advanced function usage
- Extended function parameters handling (usage of default parameter values, rest parameter and spread operator; simulating named parameters)
- Closure and IIFE (the use of closure – execution environment of the function; Immediately Invoked Function Expression – IIFE)
- Forwarding calls (this keyword and functions; apply, call and bind methods that allow to call functions with the indicated context)
- Decorating functions (functions as first-class citizens; passing functions as arguments and returning as results, higher order functions; decorating functions as adding new functionality using a wrapper function)
- Generators and iterators (creating and using generators; the idea of iterable objects; generators as an element of iterable objects, iterators)
- Handling asynchronous events using callback functions (concept of asynchronous programming; use of callback functions to handle asynchronous events)
