The language of the web — syntax, DOM, events, async and modern JavaScript — written by Aivasu Tech Institute's mentors. Free to read, structured to actually help you learn.
JavaScript notes by Aivasu Tech Institute cover 439 topics — from js home to javascript history — each explained with short definitions, syntax and runnable code examples. They are 100% free, need no signup, and work as quick revision for college exams, JavaScript interviews and Aivasu Tech Institute's mentor-led JavaScript course in Pitampura, Delhi.
No notes found. Try a different search term, or browse all JavaScript notes.
JavaScript is the language of the web — every interactive page, app and browser game runs on it. This free track takes you from first lines of code to modern async patterns and Web APIs.
JavaScript makes web pages interactive, from button clicks to live data. Learn what it is, how it fits alongside HTML and CSS, and why it is the most in-demand language for jobs.
JavaScript can live inside script tags or external files, and placement changes how pages load. Learn the right spots for scripts so they never block your page.
Printing output is how you see what JavaScript is doing, through console, alerts or the page itself. It is the first skill in every developer's debugging toolkit.
JavaScript syntax — statements, semicolons, whitespace — defines the grammar of the language. Getting comfortable with it makes every later topic easier.
Statements are the individual instructions a JavaScript program runs in order. Learning how they compose is the foundation of reading any script.
Comments document code and are ignored at runtime, keeping teams aligned. Good commenting explains the why, not just the what.
Variables store values under names so programs can reuse and change them. They are the first building block of every JavaScript program.
let declares variables that can be reassigned and are block-scoped. It replaced var for most modern code and prevents a whole class of bugs.
const declares variables that cannot be reassigned, the default choice in modern JavaScript. It signals intent and protects values from accidental changes.
JavaScript values have types — number, string, boolean, object and more. Understanding the type system is essential because JS converts types freely.
Operators compute, compare and combine values, forming the expressions of every program. This overview maps the full operator family.
Arithmetic operators handle addition, subtraction, multiplication and division. They turn JavaScript into a calculator and power every computation.
Assignment operators store values and update them compactly with +=, -= and friends. They make counters and accumulators concise.
Comparison operators test equality and ordering, producing booleans that drive decisions. Understanding loose versus strict equality is crucial.
Conditional logic branches code based on true or false, from if statements to switch. It is how programs start making decisions.
if statements run code only when a condition holds, the most basic decision structure. Conditions built from comparisons gate almost all logic.
if-else offers two paths — one when the condition is true, another when false. It is the everyday either-or of programming.
The ternary operator compresses if-else into a single expression, perfect for assignments and JSX. It reads as a question with two answers.
switch matches a value against several cases, a cleaner alternative to long if-else chains. It powers menus, state machines and command handlers.
Booleans hold true or false, the outcome of every comparison and the fuel of all branching. They are small values with enormous responsibility.
Logical operators — AND, OR, NOT — combine boolean conditions into complex rules. Their short-circuit behaviour is a powerful but tricky feature.
Loops repeat code until a condition changes, the engine of automation. Learning the loop family is where programming stops feeling manual.
The for loop repeats a block a known number of times with a counter. It is the classic workhorse for arrays and numeric ranges.
The while loop repeats as long as a condition holds, ideal for unknown iteration counts. Careful condition control prevents infinite loops.
break exits a loop early when continuing is pointless. It is how searches stop the moment they find what they need.
continue skips the rest of an iteration and jumps to the next one. It filters out unwanted cases without restructuring the loop.
Control flow is the order your program executes statements — branches, loops and jumps. Seeing the flow before writing code prevents logic errors.
Strings hold text, and JavaScript wraps them in a rich toolkit of methods. Almost every app formats, slices and searches strings daily.
Template literals embed variables into strings with backticks and ${}. They replaced concatenation as the modern way to build text.
String methods transform text — case changes, trimming, slicing, replacing. A tour of the essentials saves writing loops for built-ins.
String search methods find positions and matches inside text, from indexOf to includes. They power filters, validators and autocomplete.
JavaScript has one number type covering integers and decimals, with quirks to respect. Precision and NaN behaviour matter in real calculations.
Number methods format and convert numeric values — toFixed, toPrecision, toString. They prepare numbers for display and storage.
Number properties expose constants like MAX_VALUE and NaN handling. They define the boundaries of what JavaScript numbers can represent.
Bitwise operators manipulate individual bits of integers, rare in apps but common in interviews and low-level work. They complete the operator picture.
BigInt handles integers beyond the safe number range, essential for large IDs and precise counting. It fixes the classic 0.1 + 0.2 surprise class.
Functions bundle reusable logic under a name with parameters and returns. They are the primary unit of organised JavaScript code.
This introduction to functions covers why they exist and how to define them. Functions turn repeated code into reusable, testable blocks.
Function invocation runs the code inside, with several calling styles affecting this. Understanding invocation is key to the this keyword.
Parameters pass values into functions, with defaults and rest parameters for flexibility. They make functions adaptable to different inputs.
return sends a value back from a function, ending its execution. Every calculation in your app flows through a return statement.
The arguments object holds all passed values, a legacy feature replaced by rest parameters. Knowing it helps read older codebases.
Function expressions store functions in variables, enabling first-class use. They are the pattern behind callbacks and event handlers.
Arrow functions offer concise syntax and lexical this, making them the default for modern code. They transformed how JavaScript is written.
Timers schedule code to run later or repeatedly with setTimeout and setInterval. They power notifications, animations and polling.
Objects group related data under named keys, the foundation of JavaScript. Nearly everything in the language is built on objects.
This introduction to objects shows how key-value pairs model real things. Objects are how JavaScript represents data like users and products.
Object properties store values under keys, accessible with dot or bracket notation. Managing properties is the core object skill.
Methods are functions stored inside objects, giving objects behaviour. They bundle data and the actions that operate on it.
this refers to the object calling a method, and its binding rules are famously subtle. Understanding this unlocks object-oriented JavaScript.
Displaying objects means looping over keys or converting to strings. Learn to inspect and render objects for debugging and UI.
Constructor functions create many similar objects with shared structure. They predate classes but still power much legacy code.
Scope decides where variables are visible — global, function or block. Scope errors are among the most common JavaScript bugs.
Code blocks created by braces form scopes for let and const. Block scoping is the modern rule that replaced var's looseness.
Hoisting moves declarations to the top of their scope at runtime. It explains why some variables are usable before their line.
var, let and const differ in scope, hoisting and reassignment. Choosing correctly is a modern-code baseline expectation.
Strict mode tightens JavaScript's rules, catching silent mistakes as errors. It is the safety net enabled in every serious codebase.
Dates represent points in time, with creation, formatting and arithmetic methods. Almost every app records timestamps somewhere.
Date formats control how timestamps display for users across locales. Formatting dates well is a constant frontend task.
Date get methods read year, month, day and time components. They extract the pieces needed for calendars and schedules.
Date set methods change components of a date, enabling calculations like add-a-month. Date arithmetic powers bookings and reminders.
Arrays store ordered lists of values, JavaScript's most-used structure. Map, filter and loops over arrays are everyday work.
The Array constructor creates arrays, though literal syntax is preferred. Knowing the pitfalls of Array(5) versus [5] prevents bugs.
Array methods — push, pop, splice, slice — manipulate lists in place or return new ones. This toolkit covers most list handling.
Array search methods find elements by value or condition, from indexOf to find. They power filtering and lookups across datasets.
Sorting arrays arranges values with custom comparators, with surprising default behaviour for numbers. Mastering sort() is a rite of passage.
Array iteration methods — forEach, map, filter, reduce — replace loops with declarative pipelines. They are the heart of modern data handling.
const arrays can still be mutated even though the reference cannot change. Understanding this distinction avoids a common misconception.
Sets store unique values with fast membership checks, like a mathematical set. They deduplicate data in one line.
Set methods add, delete and test values with a small, clean API. They handle collections where duplicates must never exist.
Set logic — union, intersection, difference — solves overlap questions between collections. It is set theory applied to real data.
WeakSets hold objects weakly so they can be garbage collected. They suit bookkeeping where memory should not be pinned.
Maps store key-value pairs with any key type and insertion order. They are the modern upgrade over plain objects for lookups.
Map methods set, get, delete and iterate entries with a clean API. They make dictionary-style code explicit and fast.
WeakMaps hold object keys weakly, ideal for private data and caching. They avoid memory leaks object-keyed storage can cause.
Iteration walks through collections with loops and iterators. This topic covers the patterns that process lists and objects.
Iterables are collections that can be looped with for-of, including arrays and strings. Understanding the protocol explains the loop family.
Iterators produce values one at a time via next(), the machinery behind loops. They make custom collections loopable.
Generators pause and resume execution with yield, producing lazy sequences. They simplify iterators and infinite streams.
The Math object provides constants and functions for mathematics — rounding, powers, trigonometry. It turns JavaScript into a scientific calculator.
Math.random generates pseudo-random numbers, the seed of games, shuffles and testing. Scaling it to ranges is a common recipe.
Regular expressions match patterns in text with terse syntax, from emails to phone numbers. They are dense but indispensable for validation.
Regex flags modify matching behaviour — global, case-insensitive, multiline. They change what a pattern matches without rewriting it.
Character classes match sets of characters like digits or letters in one token. They compact long alternations into readable patterns.
Metacharacters give regex its power — anchors, dots, alternation. Learning them is the first step to fluent pattern writing.
Assertions match positions rather than characters, like start-of-line or lookaheads. They add context conditions without consuming text.
Capture groups extract substrings from matches and enable backreferences. They turn pattern matching into data extraction.
Quantifiers control how many times a token repeats, from optional to unlimited. They are how patterns match variable-length text.
Regex patterns combine tokens into complete expressions for real-world formats. Assembling patterns from parts is the practical regex skill.
The RegExp object builds patterns dynamically with test and exec methods. It is the programmatic side of regular expressions.
String methods like match, replace and search integrate regex into everyday code. They make text processing concise and powerful.
JavaScript's type system — primitives and objects — underpins every operation. This overview maps the types and their behaviour.
Primitive types are immutable single values: string, number, boolean and friends. They are compared and copied by value.
Object types are mutable references — objects, arrays, functions. Reference semantics explain the classic copy surprises.
Symbols create guaranteed-unique identifiers, ideal for private-like keys. They prevent name collisions in shared code.
typeof inspects a value's type at runtime, with famous quirks around null and arrays. It is the first tool when debugging data.
undefined marks declared but unassigned variables, the default absence signal. Distinguishing it from null is a rite of passage.
NaN means not-a-number, the result of failed numeric operations. Its never-equal-to-itself behaviour is a famous gotcha.
toString converts values to strings, from numbers to arrays. Explicit conversion prevents the surprises of implicit coercion.
toLocaleString formats values per locale — currency, dates, numbers. It is how apps speak the user's regional conventions.
Type coercion converts values implicitly during operations, famously with == and +. Mastering its rules eliminates a class of bugs.
Explicit type conversion uses functions like Number and String to control types. It is the deliberate version of coercion.
Destructuring unpacks arrays and objects into variables in one statement. It makes extracting data from props and payloads concise.
Errors interrupt execution with an exception object, and handling them keeps apps alive. This topic covers the try-catch family.
Some errors fail silently, especially in async contexts and old browsers. Knowing the silent traps keeps data from vanishing.
Error statements — try, catch, finally, throw — define error handling flow. finally runs whether the try succeeded or failed.
The Error object carries name, message and stack trace for diagnosis. Creating custom error types sharpens debugging.
Debugging is the systematic hunt for why code misbehaves. Modern browser devtools turn it from guessing into science.
The console is the developer's first debugging tool, from logs to tables and timing. Structured logging finds bugs fast.
Breakpoints pause execution at chosen lines so you can inspect state step by step. They are the professional way to debug logic.
Debugging errors means reading messages and stack traces to find the source line. It is a skill you will use your entire career.
Async debugging traces timing issues in promises and callbacks, the hardest bugs to reproduce. Devtools async stacks make them visible.
A style guide standardises naming, indentation and structure across a team. Consistent code is faster to read and cheaper to maintain.
Best practices distil years of experience — clean functions, early returns, meaningful names. Following them prevents most common bugs.
Common JavaScript mistakes — off-by-one, loose equality, misused this — trap beginners predictably. Seeing them once spares you repeatedly.
Performance optimisations keep pages fast — caching selectors, throttling, batch DOM updates. Fast code is a user experience feature.
Projects apply everything learned so far into working applications. Building is where JavaScript concepts become real skills.
Event listeners attach functions to user interactions like clicks and keys. addEventListener is the backbone of interactive pages.
The to-do list is the classic first project, combining arrays, DOM updates and events. Build it to consolidate the fundamentals.
Modal popups overlay content with a dimmed background, built with DOM toggling. They appear in almost every real application.
Form validation checks input before submission, client-side for speed. It combines events, conditions and user feedback.
JavaScript evolves through yearly ECMAScript releases, each adding features. Knowing the version history frames modern syntax.
The 2026 JavaScript edition continues the yearly feature cycle with refinements. Staying current keeps your code idiomatic and future-proof.
ES2025 shipped the latest standard library and syntax improvements. This topic covers the features that landed this year.
ES2024 added array grouping, Promise.withResolvers and more. These features are already usable in modern runtimes.
ES2023 introduced array findLast and changed-array-by-copy methods. They are small additions with daily utility.
ES2022 brought class fields, private members and top-level await. It modernised classes and module ergonomics.
ES2021 delivered logical assignment operators and numeric separators. These quality-of-life features appear across codebases.
ES2020 introduced optional chaining, nullish coalescing and BigInt. They removed some of JavaScript's most annoying boilerplate.
ES2019 added flat and flatMap for arrays and Object.fromEntries. Array handling got noticeably cleaner this year.
ES2018 shipped async iteration, rest/spread for objects and promise.finally. Async programming became far more ergonomic.
ES2017 brought async/await, the syntax that changed asynchronous JavaScript forever. It made promise code read like synchronous flow.
ES2016 was a small release — includes and exponentiation. Even small releases matter in a yearly language.
ES6 was the biggest JavaScript update ever — classes, arrows, modules, let and const. It defined the modern language.
ES5 standardised the language with strict mode, JSON and array methods. It laid the foundation browsers rely on today.
ES3 was the long-lived standard behind a decade of web development. It is where modern JavaScript's core solidified.
This recap of JavaScript versions ties the release history together. It frames which features are safe to use everywhere.
JavaScript's history — ten days at Netscape to the world's most-used language — explains its quirks. Knowing the story deepens the learning.
The DOM is the browser's model of the page, and JavaScript manipulates it live. This is where JavaScript meets HTML directly.
The DOM API provides the methods and properties for reading and changing documents. It is the interface between scripts and pages.
Selecting elements grabs page nodes with querySelector and friends. It is the first step of any DOM manipulation.
Changing HTML updates content, attributes and structure on the fly. innerHTML and textContent drive dynamic pages.
Changing CSS through the DOM adjusts styles dynamically, from themes to animations. classList toggles are the cleanest approach.
DOM-based form validation uses the Constraint Validation API for built-in checks. It pairs with JavaScript for custom rules.
DOM animations move elements with timers, transforms and requestAnimationFrame. They bring interfaces to life without libraries.
HTML events — clicks, inputs, loads — are how users talk to your code. Handling them is the core of interactivity.
Mouse events track clicks, moves and hover transitions across the page. They power everything from buttons to drag interfaces.
Keyboard events capture key presses for shortcuts, games and form control. They enable power-user interactions.
Load events fire when resources finish loading, timing scripts correctly. They prevent the classic null-element errors.
Managing events covers adding, removing and delegating listeners. Event delegation handles dynamic content efficiently.
Event examples walk through real interactions — menus, galleries, live previews. They connect event theory to working features.
This addEventListener topic details options like once and capture. Fine-grained control over listeners prevents leaks and duplicates.
HTML-first development prioritises markup before scripts, improving reliability. It is the progressive enhancement philosophy.
Progressive enhancement builds baseline functionality first, then layers enhancements. Sites keep working even when scripts fail.
HTML-first features use native elements before JavaScript — details, dialog, form validation. Native beats custom where it exists.
HTML-first CSS prefers semantic markup and modern CSS over JavaScript styling. It keeps styling fast and maintainable.
The window object is the global context with methods for sizing, scrolling and dialogs. It is the root of browser-side JavaScript.
The screen object describes the user's display — width, height, colour depth. It informs responsive and adaptive design choices.
The location object reads and changes the page URL, enabling redirects and parsing. It is the browser's address bar API.
The history API moves through the back/forward stack and pushes entries. It powers single-page app navigation.
The navigator object exposes browser details, online state and device info. It is the gateway to platform capabilities.
Popup dialogs — alert, confirm, prompt — block for simple messages and choices. They are blunt tools with niche uses.
Cookies store small data on the user's machine for sessions and preferences. Secure cookie handling is a professional requirement.
fetch requests data from servers and is the modern replacement for XMLHttpRequest. It is how frontends talk to APIs.
JSON is the universal data format of the web, and JavaScript parses it natively. Nearly every API you consume speaks JSON.
JSON syntax is strict — double quotes, no comments, no trailing commas. Small mistakes break parsing silently.
JSON values are strings, numbers, booleans, null, arrays and objects. Knowing the valid set prevents serialisation errors.
JSON.parse converts JSON text into JavaScript objects with error handling. It is the read side of every API call.
JSON.stringify converts JavaScript values to JSON text, with replacers for custom shapes. It is the write side of data exchange.
Fetching JSON combines fetch with parse into a reusable data-loading pattern. It is the most common real-world request flow.
Rendering JSON into HTML turns API data into visible UI. It connects the data layer to the interface layer.
JSON versus XML compares the two data formats across web history. JSON won for its simplicity and JavaScript fit.
Web APIs give JavaScript access to browser capabilities — storage, workers, geolocation. They are the platform beyond the language.
The Geolocation API provides the user's location for maps and local services. Permissions and privacy shape its usage.
The Pointer Events API unifies mouse, touch and pen input into one model. It simplifies cross-device interaction code.
Web Storage persists data in the browser across sessions without cookies. localStorage and sessionStorage power saved state.
The Constraint Validation API provides built-in form checks and messages. It upgrades forms with native validation hooks.
Web Workers run scripts on background threads, keeping pages responsive. Heavy computation no longer blocks the UI.
The Temporal API is the modern replacement for Date, fixing decades of quirks. It brings precise, immutable date-time handling.
This topic explains why Temporal exists and what Date got wrong. Understanding the motivation makes the new API click.
Temporal versus Date compares the two APIs side by side for common tasks. The contrast shows exactly what improves.
Temporal Duration represents a span of time like two hours and thirty minutes. Durations make time arithmetic explicit.
Temporal Instant is an exact moment in time, ideal for timestamps. It is the unambiguous point on the timeline.
PlainDateTime is a date and time without timezone, for local schedules. It separates wall-clock values from global instants.
PlainDate represents a calendar date without time, like 2026-09-20. It suits birthdays, deadlines and date-only logic.
PlainYearMonth tracks a month in a year for recurring bills and subscriptions. It handles month-level precision cleanly.
PlainMonthDay represents a month and day without a year, like December 25th. It models yearly recurring events.
PlainTime is a time of day without a date, for schedules and alarms. It handles wall-clock times precisely.
ZonedDateTime combines a date, time and timezone into one value. It is the correct way to represent real-world moments.
Temporal Now reads the current time across all Temporal types. It replaces new Date() with intent-revealing calls.
Temporal arithmetic adds and subtracts dates and durations with clear rules. It removes the old month-rollover surprises.
Since and Until compute the difference between two times, optionally rounded. They make duration calculations readable.
Temporal comparison orders dates and instants with compare methods. Sorting schedules and timelines becomes straightforward.
Temporal conversion moves values between types and timezones safely. It is how data flows in and out of the API.
Temporal formats values to strings in multiple styles and locales. Displaying dates for users is part of the same API.
This topic collects the common Temporal mistakes and misunderstandings. Seeing them early saves debugging later.
Migrating from Date to Temporal maps old patterns to new ones. A practical guide smooths the transition.
Temporal follows the ECMAScript standards process and ISO conventions. It is the future-proof date API of the language.
Advanced function techniques — this binding, closures, currying — separate senior developers. This section goes beyond basics.
Function definitions cover declarations, expressions and arrows side by side. Choosing the right form sets the code's structure.
Callbacks are functions passed to run later, the heart of asynchronous JavaScript. They power events, timers and data loading.
The this keyword inside functions depends on how they are called. Its binding rules are the classic JavaScript interview topic.
call invokes a function with a chosen this and listed arguments. It is how libraries borrow and customise methods.
apply is call's sibling, passing arguments as an array. It suits functions with dynamic argument counts.
bind creates a new function with this locked in place. It fixes the losing-this problem in callbacks once and for all.
IIFEs run functions immediately after definition, isolating scope. They were the module pattern before modules existed.
Closures let functions remember their lexical scope after it returns. They are the engine behind private state and factories.
Advanced object techniques — accessors, prototypes, protection — take objects beyond key-value storage. This section goes deeper.
Object definitions compare literal syntax, constructors and Object.create. The options trade clarity for flexibility.
This topic revisits this across methods, events and strict mode. Context confusion is the source of countless bugs.
Iterating objects walks keys, values and entries with modern methods. Object.entries turns objects into loopable arrays.
Getters and setters run code on property access and assignment. They add validation and computed values behind plain syntax.
Object management controls extensibility and configuration with defineProperty. It is the precision tool for object behaviour.
Object protection seals or freezes objects against change. It defends data integrity in shared state.
Prototypes chain objects to share methods and properties. They are JavaScript's inheritance model beneath the class syntax.
Classes define reusable blueprints with methods, constructors and inheritance. They organise JavaScript's object model clearly.
Class inheritance extends one class from another with super. It builds hierarchies while sharing and overriding behaviour.
Static members belong to the class itself, not instances. They hold utilities and shared constants.
Asynchronous JavaScript keeps apps responsive while waiting for data and timers. This section covers the full async toolbox.
Async programming structures code around operations that finish later. Callbacks, promises and async/await are the three generations.
Callbacks were the original async pattern, now infamous for nesting. Understanding them explains why promises exist.
Promises represent values that will resolve later, with then and catch. They flattened callback pyramids into chains.
async/await writes promise-based code like synchronous flow. It is the modern standard for readability and error handling.
Running async tasks in parallel with Promise.all speeds up independent work. It turns sequential waits into one wait.
The event loop schedules callbacks, promises and rendering in a single thread. It is the engine room of JavaScript's concurrency.
Async fetch loads data with promises and await in clean flows. It is the standard pattern for API-driven interfaces.
Common async mistakes — forgotten awaits, unhandled rejections, races — surface here. Avoiding them keeps production stable.
Debugging async code traces timing across promises and loops. Devtools async stacks reveal the flow.
AbortController cancels in-flight fetches and timers. It cleans up abandoned requests and prevents stale updates.
Web Workers move heavy work off the main thread entirely. They are the escape hatch when async is not enough.
Modules split code into files with explicit imports and exports. They are how every modern JavaScript project is organised.
Export makes functions and values available to other files. Named and default exports cover the two usage styles.
Import brings exported values into a file with named or default syntax. It is the other half of the module system.
Namespace imports bundle all exports under one object. They keep access explicit when importing many things.
Dynamic import loads modules on demand with import(). It powers code splitting and lazy-loaded features.
Meta-programming with Reflect and Proxy lets code inspect and intercept objects. It is JavaScript's advanced reflection layer.
Reflect provides methods that mirror internal operations like defineProperty. It standardises meta-programming calls.
Proxy wraps objects to intercept operations like reads and writes. It powers reactivity systems and validation layers.
Typed arrays store binary numbers efficiently for graphics and processing. They are how JavaScript handles raw data.
Typed array methods mirror regular arrays with numeric guarantees. They process binary data with familiar APIs.
ArrayBuffers are raw blocks of memory that typed arrays view. They are the foundation of binary data handling.
DataViews read and write an ArrayBuffer with explicit byte offsets and types. They give byte-level control over binary data.
Atomics provide lock-free operations shared between threads. They coordinate work across Web Workers safely.
DOM navigation moves between nodes — parents, children, siblings. It is how scripts traverse the document tree.
DOM nodes are the elements, text and attributes that make up a page. Node properties and methods are the traversal toolkit.
DOM collections like HTMLCollection are live lists that update with the document. Their live nature surprises newcomers.
NodeLists hold groups of nodes from querySelectorAll, static or live. Converting to arrays unlocks iteration methods.
JavaScript graphics span canvas, SVG and charting libraries. This section maps the browser's visual capabilities.
Canvas draws pixels with a 2D API — shapes, images, text. It powers games, visualisations and photo editing.
Plotly builds interactive scientific charts with a JavaScript API. It is the choice for data-heavy visualisations.
Chart.js renders responsive charts from simple configuration objects. It is the fastest route from data to a dashboard.
Google Charts provides free chart types through a hosted loader. It suits quick dashboards without heavy dependencies.
D3 binds data directly to SVG elements for custom visualisations. It is the power tool behind bespoke data graphics.
AJAX updates parts of a page without reloading, using async requests. It turned static pages into applications.
XMLHttpRequest was the original AJAX API, still found in legacy code. Its verbose flow explains fetch's design.
AJAX requests open connections, send data and read responses. The request lifecycle is the core of the pattern.
AJAX responses carry status codes and bodies that scripts handle. Interpreting responses correctly drives UI updates.
AJAX can fetch XML documents and parse them with DOM methods. It is a legacy format with niche uses today.
AJAX with PHP connects frontend requests to server-side scripts. It is the classic dynamic-website architecture.
AJAX with ASP pairs the request pattern with Microsoft's server stack. Legacy enterprise apps still use this combination.
AJAX database interactions fetch records from a server without page reloads. It is the read pattern behind live tables.
AJAX applications showcase real uses — live search, autocomplete, voting. They demonstrate the pattern's practical power.
AJAX examples walk through complete request-and-update flows. They tie the API calls into working features.
jQuery simplified DOM manipulation and AJAX for a decade of the web. Understanding it matters for maintaining older projects.
jQuery's HTML methods read and write content with short selectors. They replaced verbose DOM code in their era.
jQuery's CSS methods get and set styles with chaining. They simplified dynamic styling before modern APIs matured.
jQuery's DOM methods traverse and manipulate the document tree. They are the historical patterns modern code replaced.
JSONP loaded cross-origin data via script tags before CORS existed. It is a legacy technique worth recognising in old code.
What JavaScript is and the role it plays as the browser's native programming language.
The three places JS can live: inline, in a script block, or in an external file.
How scripts send results to the console, the document, an alert or an HTML element.
The basic grammar of the language: values, operators, comments and statements.
How instructions are formed and terminated, and the role of semicolons.
Single-line and multi-line comments for documenting code.
Storing values in named containers and how assignment works.
Block-scoped variables declared with let and why they are preferred.
Immutable bindings with const and when to reach for them.
The symbols that perform arithmetic, assignment, comparison and logical work.
Addition, subtraction, multiplication, division, modulus and increment.
Setting values with = and its compound shortcuts.
Testing equality and order, and the difference between == and ===.
A compact if/else expression that returns one of two values.
Running code only when a condition is true.
Choosing between two branches based on a condition.
Matching one value against many cases cleanly.
True and false values and how other types coerce to them.
Combining conditions with and, or and not.
Repeating work while a condition holds.
Counting through a range with an explicit counter.
Repeating until a condition becomes false.
Exiting a loop early.
Skipping to the next loop iteration.
How execution order, loops and conditionals shape a program.
Text values and the ways they can be created.
Embedding expressions inside template literals.
Common operations like slice, replace, split and trim.
Finding text with indexOf, includes and match.
How the language represents integers and decimals as one type.
Formatting and converting numbers, such as toFixed and parseInt.
Constants like MAX_VALUE and EPSILON.
Manipulating numbers at the binary level.
Whole numbers larger than the safe integer limit.
Reusable blocks of code that perform a task.
Sending a result back to the caller.
Accessing all arguments passed to a function.
A concise function syntax and how it differs from traditional functions.
Delaying and repeating code with setTimeout and setInterval.
Collections of key-value pairs for modelling real things.
Referring to the object a method belongs to.
Turning an object into readable text.
Where a variable is visible and for how long.
How braces create scopes.
Why declarations appear to move to the top of their scope.
Comparing the three declaration keywords and their scoping rules.
Opting into a stricter, safer variant of the language.
Representing and working with points in time.
The strings JavaScript accepts and produces for dates.
Reading year, month, day and time from a date.
Changing parts of a date.
Ordered lists of values.
Different ways to create an array.
Adding, removing and transforming elements.
Finding items with indexOf, includes and find.
Ordering arrays and the default sort gotcha.
Looping and mapping over arrays.
Why a const array can still change.
Collections of unique values.
Adding, deleting and checking membership.
Union, intersection and difference between sets.
A set that holds objects without preventing garbage collection.
Key-value collections where keys can be any type.
Getting, setting and iterating a map.
A map with object keys and automatic cleanup.
Values a for...of loop can walk through.
The protocol behind stepping through a sequence.
Functions that produce a sequence of values on demand.
Built-in constants and functions for mathematics.
Generating pseudo-random numbers.
Patterns for matching text.
Modifiers like global, ignore-case and multiline.
The syntax for describing what to match.
Special symbols like dot, word and digit.
How many times a token may repeat.
Sets and ranges of allowed characters.
Matching positions such as start, end and word boundaries.
Capturing and referencing parts of a match.
Testing and matching with regular expressions.
The primitive and reference types at a glance.
The simple, immutable value types.
Everything that is a reference value.
Unique identifiers that never collide.
Inspecting a value's type at runtime.
The value of a declared but unassigned variable.
The result of an invalid numeric operation.
Converting values to strings.
Locale-aware formatting of numbers and dates.
How JavaScript converts types implicitly.
Converting between types on purpose.
Pulling values out of arrays and objects in one step.
What goes wrong at runtime and why it matters.
Bugs that fail quietly without throwing.
Throwing your own errors deliberately.
The built-in error types and their properties.
A methodical approach to finding bugs.
Logging and inspecting values while you debug.
Pausing execution in the browser tools.
Reading stack traces and error messages.
Tracing problems in asynchronous flows.
Conventions that keep code readable and consistent.
Habits that make JavaScript safer and clearer.
The errors beginners hit most often.
Writing JavaScript that stays fast.
The tree the browser builds and how scripts see it.
The core APIs for working with the document.
Reading and writing an element's markup and text.
Walking between parents, children and siblings.
Array-like groups of elements.
The results returned by query methods.
How user actions trigger code.
Adding and removing listeners cleanly.
The addEventListener model and the event object.
The global object that represents the browser tab.
Information about the user's display.
Reading and changing the current URL.
Navigating backward and forward in the session.
Details about the browser and device.
alert, confirm and prompt dialogs.
Storing small pieces of data on the client.
The text format used to exchange structured data.
The values JSON can represent.
Loading data from a server.
The modern promise-based way to make HTTP requests.
Browser features JavaScript can call.
Reading the user's location with permission.
Unified handling for mouse, touch and pen.
localStorage and sessionStorage for client data.
Built-in browser form validation.
Running scripts on background threads.
Passing functions to run later.
How this is decided at call time.
Controlling the this value explicitly.
Immediately-invoked function expressions.
Functions that remember their surrounding scope.
Computed properties with accessor functions.
Enumerating, defining and deleting keys.
Freezing and sealing to prevent changes.
The chain JavaScript uses for inheritance.
Syntactic sugar over prototypes for object-oriented code.
Extending one class from another.
Methods that belong to the class itself.
Why long tasks must not block the main thread.
A cleaner model for eventual results.
Running several operations at once.
How JavaScript schedules async work on one thread.
The traps that cause race conditions and unhandled rejections.
Cancelling a request in flight.
Splitting code into reusable files.
Publishing values from a module.
Bringing values into a module.
Importing a whole module as an object.
Loading modules on demand.
Code that inspects and alters other code.
A modern API for object operations.
Intercepting and customising object behaviour.
Fixed-type numeric arrays for performance.
Working with typed array data.
Reading binary data at specific offsets.
Safe operations on shared memory.
Drawing and visualising data in the browser.
Pixel-level 2D drawing with the canvas element.
Interactive charts with the Plotly library.
Simple responsive charts with Chart.js.
Embedding Google's chart library.
Data-driven documents for custom visualisations.
The landmark update that modernised the language.
The baseline many older codebases still target.
How the language is standardised and evolves yearly.
Where the language came from and how it grew.
Join Aivasu Tech Institute's JavaScript course — live mentorship, hands-on projects, and 100% placement support in Delhi NCR.
Enroll Now — Free Demo Available✳ Common questions
What students search before reading JavaScript notes.