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