PROWIDIT Education Academy

Blog
About us
How it works
FAQ

+994 77 333 38 36 Trial lesson Account

AZ RU EN

← Back to account

Switch courseJavaScript course

AI for developers course104
Algorithms and data structures course129
Django & FastAPI course140
Docker & deployment course103
Full Stack Developer course270
Git & GitHub course103
HTML & CSS course154
JavaScript course169
Laravel course136
Provider Networks: MPLS, BGP and BNG81
Next.js course113
Node.js course123
PHP course144
Python course153
React course122
SQL & databases course122
TypeScript course112
Vue.js course111

Getting Started with JavaScript
What JavaScript Is and Where It Runs Free
Adding JavaScript to a Page: script, defer, async and Modules
DevTools and the Console: console.log, table, group, time
Dev Environment: VS Code, Node.js 22 and Running Scripts
Syntax: Statements, Semicolons, Comments and Strict Mode
Variables: let, const and Naming Rules
Simple User Dialogs: alert, prompt and confirm
Data Types and Operators
Data Types and the typeof Operator
Numbers and Arithmetic Operators
Strings: Quotes, Template Literals and Concatenation
Booleans: true, false, Truthy and Falsy Values
null vs undefined: What's the Difference
Comparison Operators: == vs === and String Comparison
Type Conversion: Explicit and Implicit Coercion
Logical Operators &&, || and !: Short-Circuit Evaluation
The ?? Operator and Logical Assignment: ||=, &&=, ??=
Conditions and Loops
Conditionals: if, else if and else
The Ternary Operator and Conditional Expressions
The switch Statement: case, break and default
while and do...while Loops
The for Loop: Counters, Steps and Nested Loops
Loop Control: break, continue and Labels
Project: Guess the Number Game
Functions
Function Declarations: Parameters, Arguments and Calls
Returning Values: return and Early Exit
Function Expressions: Functions as Values
Arrow Functions
Default Parameters and Rest Parameters
Callbacks and Higher-Order Functions
Scope: Global, Function and Block
Hoisting, var and the Temporal Dead Zone
Closures: How Functions Remember Their Scope
Recursion and the Call Stack
Project: A Digital Wallet Built on Closures
Objects
Objects: Literals, Properties, Dot and Bracket Notation
Property Shorthand and Computed Keys
Object Methods and a First Look at this
Objects by Reference: Comparison and Mutation
Copying Objects: Spread, Object.assign and structuredClone
Object Destructuring
Optional Chaining ?.: Safe Property Access
Arrays and Array Methods
Arrays: Creation, Indexes, length and at()
Adding and Removing Items: push, pop, shift, unshift, splice
Iterating Arrays: for, for...of and forEach
Array Destructuring and Spread Syntax
Searching and Checking: find, findLast, some, every
map and filter: Transforming and Filtering Arrays
reduce: Folding an Array into a Single Value
Iterating Objects: for...in, Object.keys, values and entries
Grouping Data with Object.groupBy
Sorting: sort, Compare Functions and localeCompare
Non-Mutating Methods: slice, concat, toSorted, toReversed, with
Creating and Reshaping: Array.from, fill, flat, flatMap, join
Project: Online Store Order Analytics
Strings, Regular Expressions, Numbers and Dates
String Methods: Searching and Checking
String Methods: Slicing, Replacing, split and join
Regular Expressions: Syntax, Flags and Character Classes
RegExp: Quantifiers, Groups and Alternation
RegExp in Practice: match, matchAll, replace and Validation
Working with Numbers: Math, Rounding, parseInt and BigInt
The Date Object: Creating Dates and Reading Components
Date Arithmetic and Time Zones
Intl.DateTimeFormat and RelativeTimeFormat: Formatting Dates
Intl.NumberFormat, PluralRules and ListFormat
Project: Text Analyzer with a Multilingual Report
Map, Set, JSON and Iterators
Map: Keys of Any Type
Set: Unique Values and Set Operations
WeakMap, WeakSet and Garbage Collection
JSON: JSON.stringify and JSON.parse
Symbol: Unique Keys and Well-Known Symbols
Iterators and Iterables
Generators: function* and yield
OOP: this, Prototypes and Classes
this: How the Context Is Determined
call, apply and bind: Controlling the Context
Constructor Functions and the new Operator
Prototypes and the Prototype Chain
Classes: constructor, Methods and Fields
Inheritance: extends, super and instanceof
Getters and Setters
Static Properties and Methods
Private Fields and Methods with #
Project: A Class-Based Library Management System
Errors and Debugging
Handling Errors: try, catch and finally
The Error Object, Error Types and throw
Custom Error Classes: extends Error
Debugging in DevTools: Breakpoints and debugger
Common Errors and Debugging Strategies
Working with the DOM
What the DOM Is: the Node Tree and document
Selecting Elements: querySelector, getElementById, closest
Traversing the DOM: Parents, Children and Siblings
Element Content: textContent, innerHTML and innerText
Attributes and Properties: getAttribute, setAttribute, dataset
classList and Styles: Managing Classes and CSS
Creating, Inserting and Removing Elements
Rendering from Data: template, DocumentFragment, replaceChildren
Sizes and Scrolling: getBoundingClientRect and scrollIntoView
Events
Event Listeners: addEventListener and removeEventListener
The Event Object: target, currentTarget and preventDefault
Event Propagation: Bubbling and Capturing
Event Delegation
Mouse and Pointer Events
Keyboard Events: keydown, key and code
Page Lifecycle: DOMContentLoaded, load, scroll and resize
Custom Events: CustomEvent and dispatchEvent
Project: Calculator
Project: Image Slider
Forms and Browser Storage
Working with Forms: form.elements, value, checked and select
Form Events: submit, input, change and FormData
Built-in Validation: the Constraint Validation API
Custom Validation in JavaScript: Rules and Error Messages
Project: Registration Form with Validation
localStorage and sessionStorage: Storing Data in the Browser
Project: To-Do List with localStorage
Asynchronous JavaScript
Timers: setTimeout and setInterval
The Event Loop: Call Stack and Task Queue
Microtasks and Macrotasks: Execution Order
Asynchronous Callbacks and Callback Hell
Promises: States, then, catch and finally
Promise Chaining and Errors in Chains
Promise.all, allSettled, race, any and withResolvers
async/await: Writing Async Code in a Synchronous Style
Async Error Handling: Parallel vs Sequential Execution
Project: Quiz App with a Timer
Networking: fetch and REST APIs
HTTP and REST for Frontend: Methods, Status Codes, Headers
GET Requests with fetch: Response, json() and URLSearchParams
Sending Data: POST, PUT, PATCH and DELETE
Network Errors, Timeouts and AbortController
Loading States in the UI and Request Race Conditions
API Authentication: Keys, Tokens and CORS
Project: Weather App Using a Public API
Browser APIs
The BOM: window, location, navigator and screen
History API: pushState, popstate and Simple Routing
IntersectionObserver: Lazy Loading and Infinite Scroll
Geolocation and Clipboard APIs: Working with Permissions
IndexedDB: An Introduction to the Browser Database
Web Workers: Running Heavy Work in the Background
Canvas: An Introduction to Drawing
Drag and Drop API: Dragging Elements
Project: Kanban Board with Drag & Drop
Modules, npm and Tooling
ES Modules: import and export
Dynamic import(), Top-Level await and import.meta
npm: package.json, Dependencies and Scripts
Vite: Project Setup, Dev Server and Build
Code Style: ESLint and Prettier
Unit Testing with Vitest
jQuery: A Quick Overview for Reading Legacy Code
Professional Practices and Final Project
Functional Style: Pure Functions and Immutability
Currying, Partial Application and Function Composition
Debounce and Throttle: Controlling Call Frequency
Frontend Security: XSS, innerHTML vs textContent
Performance: Reflow, requestAnimationFrame and Memory Leaks
Project: SPA Product Catalog with Filters
Final Project: An Interactive Web App Powered by an API
Browser APIs and Advanced JS
WebSocket in the Browser: Two-Way Real-Time Communication
File API: Files, Blob and FileReader
`Proxy` and `Reflect`: Intercepting Object Behavior
Web Components: customElements.define, Lifecycle, Attributes and Events
Shadow DOM, <template> and Slots: Encapsulated CSS and Composing Components
Bundlers: webpack and Rollup Basics, Tree Shaking, Code Splitting
Libraries, Networking and Security
HTTP Clients: Axios vs fetch, Interceptors, Timeouts and Retry
Auth on the Client: JWT, Token Storage, Refresh and OAuth 2.0 PKCE
Utility Libraries: lodash, dayjs, date-fns and Bundle Size
Charts: Chart.js (config, datasets, options, updating) and a D3 Primer
Animation Libraries: GSAP (tweens, timelines, ScrollTrigger) vs CSS and the Web Animations API
WebRTC Basics: getUserMedia, RTCPeerConnection, Signaling and Data Channels
Graphics, Offline Mode and Audio
Three.js Basics: Scene, Camera, Light, Animation and glTF
PWA and Service Workers: Manifest, Cache and Offline Mode
Web Audio API: Sound Synthesis, Samples and Visualization
Security, Testing and Deployment
E2E Testing in Plain JS: Playwright

JavaScript course · Functions

Scope: Global, Function and Block

🔒 This is the beginning of the lesson. The full lesson is available with a subscription.

Create account Log in

← Previous lesson🔒 Callbacks and Higher-Order Functions Next lesson →🔒 Hoisting, var and the Temporal Dead Zone

PROWIDIT Education Academy

Online programming courses in Baku. Live lessons in Azerbaijani and Russian, 80% practice, mentor support and job placement assistance.

Front End

HTML & CSS JavaScript TypeScript React Next.js Vue.js

Back End

SQL (PostgreSQL, MySQL) PHP Laravel Python Algorithms Django & FastAPI Node.js Full Stack

Tools & AI

Git & GitHub Docker & deployment AI for developers

Useful links

Free trial lesson Mentoring & interviews For companies Blog FAQ

Contacts

+994 77 333 38 36 info@prowid.com Video lessons Send a request

© 2021–2026 Prowid — IT Education Academy. All rights reserved. Baku, Azerbaijan