JavaScript examples.

Print a simple greeting message to the console.

Declare variables using let, const, and var then print them.

Use template literals to embed variables in strings.

Use typeof operator to check the data types of variables.

Show single-line and multi-line comments with executable code.

Demonstrate optional semicolons and their explicit use in JavaScript.

Combine template literals with arithmetic expressions inside placeholders.

Show how let allows reassignment while const does not.

Create variables of different types and display them with type information.

Generate a formatted student report using variables, template literals, and comments.

Performs addition, subtraction, multiplication, and division on two numbers.

Demonstrates remainder and power operators with simple calculations.

Compares numbers using equality, inequality, and relational operators.

Combines boolean expressions using AND, OR, and NOT operators.

Uses conditional ternary expressions to assign values based on conditions.

Provides default values for null or undefined using nullish coalescing.

Safely accesses nested object properties that might not exist.

Combines and copies arrays using the spread operator.

Collects multiple function arguments into an array using rest parameters.

Calculates total price with discounts using arithmetic, ternary, and spread operators.

Calculate and display the length of a string using the length property.

Access individual characters in a string using bracket notation and charAt method.

Use template literals to embed variables and expressions inside strings.

Extract parts of a string using the slice method with various start and end indices.

Split a string into an array and join array elements back into a string.

Replace specific substrings using replace and replaceAll methods.

Use regular expressions to test and match patterns in strings.

Use regular expressions with replace to transform string patterns globally.

Extract multiple substrings from text using slice and indexOf methods together.

Build a text formatter that censors words, formats names, and extracts statistics using multiple string methods.

Define an array with five numbers and print it to console.

Add elements with push and remove with pop from an array.

Remove first element with shift and add at start with unshift.

Use map to transform each array element into a new value.

Use filter to create array containing only elements meeting a condition.

Use reduce to sum all numbers in an array.

Use find to locate element and some every to test conditions.

Sort numbers correctly using a custom compare function for ascending and descending.

Extract array elements into variables using destructuring syntax and rest operator.

Mini-project managing student grades with filtering sorting statistics and destructuring.

Create and print a person object with name and age properties.

Access object properties using both dot and bracket notation methods.

Extract keys, values, and entries from an object using built-in methods.

Extract properties from an object into individual variables using destructuring.

Use destructuring with default values for properties that might be missing.

Combine and clone objects using the spread operator syntax.

Create object properties dynamically using computed key names in square brackets.

Extract values from nested objects using multi-level destructuring syntax.

Define methods inside objects and access properties using this keyword.

Build a grade management system using destructuring, spread, and computed keys.

Checks if a number is positive using an if statement.

Determines if a person can vote based on age using if-else.

Prints the day name using a switch statement based on day number.

Counts down from ten to one using a for loop.

Calculates sum of numbers from one to five using while loop.

Iterates through an array of fruits using for-of loop.

Prints object properties and values using for-in loop.

Demonstrates break and continue in loops to skip and stop iteration.

Uses labeled loops to break out of nested loops early.

Mini-project combining if-else, while loop, switch and break to simulate guessing.

Declares a function and calls it to print a greeting message.

Assigns an anonymous function to a variable and invokes it.

Uses arrow function syntax to create a concise squaring function.

Defines a function with default parameter values for missing arguments.

Collects multiple arguments into an array using rest parameter syntax.

Immediately invoked function expression runs code in isolated scope.

Inner function retains access to outer function variables after execution.

Arrow functions inherit this context from surrounding scope unlike regular functions.

Combines default parameters rest syntax and closures to compose functions.

Mini-project using closures arrow functions default parameters and IIFE to manage cart.

Create a simple class with a constructor and display an instance property.

Define a class with methods that perform calculations on instance data.

Use static methods that belong to the class itself rather than instances.

Implement getter and setter methods to control property access and validation.

Create a subclass that inherits properties and methods from a parent class.

Call parent class constructor and methods using the super keyword.

Export a class from a module and import it in another file.

Export multiple classes and functions from a module using named exports.

Combine static properties with instance methods in a class hierarchy.

Build a task manager using classes inheritance getters setters and static methods.

Execute a callback function after a simple operation completes.

Use setTimeout to execute a callback after a delay.

Create and resolve a Promise with a simple value.

Handle Promise rejection using the catch method.

Chain multiple then calls to process data sequentially.

Simplify Promise handling with async and await keywords.

Handle async errors using try catch blocks.

Execute multiple Promises concurrently with Promise all.

Handle mixed success and failure outcomes with Promise allSettled.

Build a mini dashboard that fetches and processes multiple user records asynchronously.

Print numbers 1 to 20 replacing multiples of 3 with Fizz and 5 with Buzz.

Check if given strings are palindromes ignoring spaces and case.

Shift letters in a string by a fixed number to encode messages.

Create a debounce utility that delays function execution until calls stop.

Simulate button clicks with increment decrement and reset functionality.

Track elapsed time with start stop and reset methods.

Simulate fetching JSON data and displaying user information.

Validate email password and username with specific rules and display errors.

Simulate theme switching between light and dark modes with state persistence.

Build a mini router with navigation validation and themed page rendering.

Use map to double each number in an array.

Use filter to extract only positive numbers from an array.

Use reduce to calculate the sum of all numbers in an array.

Use find to locate an object and findIndex to get its position.

Use some and every to check array conditions.

Use flat to flatten nested arrays and flatMap to map then flatten.

Sort objects by age using a custom comparator function.

Demonstrate difference between splice mutating and slice copying arrays.

Chain filter map and reduce to process data in a pipeline.

Build a sales analytics tool using multiple array methods together.

Use template literals to embed variables and expressions in strings.

Use padStart and padEnd to align text in columns.

Split a sentence into words and rejoin with different separators.

Use replaceAll with regular expressions to transform text patterns.

Convert strings between upper lower and title case formats.

Use trim trimStart and trimEnd to remove whitespace selectively.

Convert between characters and their Unicode code points.

Sort strings alphabetically using localeCompare for proper ordering.

Create decorative patterns by repeating characters and combining strings.

Build a mini tool that formats text with padding reversal and case transformations.

Extract properties from an object using destructuring syntax.

Use default values when destructuring properties that might be undefined.

Extract values from nested objects using nested destructuring patterns.

Use rest to collect remaining properties and spread to copy objects.

Create objects with dynamically computed property names using bracket notation.

Convert objects to arrays and back using entries and fromEntries methods.

Demonstrate the difference between shallow and deep cloning of nested objects.

Prevent modifications to objects using freeze and seal methods.

Safely access nested properties and provide defaults with modern operators.

Build a mini inventory system using destructuring, spread, entries, and optional chaining.

Create a Map with key-value pairs and retrieve values using get method.

Demonstrate differences between Map and plain object for key types and ordering.

Loop through Map using forEach and for-of with entries keys and values.

Use Set to remove duplicate values from an array automatically.

Implement union intersection and difference operations using Set methods.

Use WeakMap to store private data associated with objects without memory leaks.

Count frequency of elements in an array using Map structure.

Group array elements by a property using Map for categorization.

Implement a basic Least Recently Used cache using Map for ordered entries.

Solve two-sum problem using Map with frequency counting and set deduplication for pairs.

Display the current date and time using the Date object.

Get year, month, day, hours, minutes, and seconds from current date.

Use Intl.DateTimeFormat to display date in different locales and formats.

Determine the weekday name for any given date using getDay method.

Compute a person's age in years given their birth date.

Add and subtract days from dates using millisecond arithmetic.

Parse and manipulate ISO 8601 date strings with timezone information.

Display the same moment in different timezones using Intl options.

Measure elapsed time between two points using Date.now for millisecond precision.

Mini-project combining date parsing, arithmetic, formatting, and relative time for event countdowns.

Demonstrate Math.floor, Math.ceil, Math.round, and Math.trunc on decimal numbers.

Generate random integers within a specified minimum and maximum range using Math.random.

Show common parsing pitfalls with parseInt and parseFloat including radix and whitespace.

Demonstrate toFixed rounding behavior and string return type with floating point precision issues.

Format numbers as currency and percentages using the Intl.NumberFormat API for localization.

Check if a number is prime using trial division with square root optimization.

Generate Fibonacci numbers up to n terms using iterative approach for efficiency.

Calculate factorial using BigInt to handle large numbers beyond JavaScript safe integer limit.

Convert numbers between binary, octal, decimal, and hexadecimal bases in both directions.

Mini-project analyzing numbers with prime check, factorial, Fibonacci, formatting, and base conversion.

Use test method to check if a string contains a specific pattern.

Compare test and match methods to extract pattern information from strings.

Use matchAll to extract all occurrences and capture groups from text.

Extract data using named groups for more readable pattern matching code.

Transform matched patterns using a callback function in replace method.

Split strings on complex patterns like multiple delimiters or whitespace.

Validate email addresses and phone numbers using regex patterns.

Compare greedy and lazy matching to extract content between delimiters.

Use flags for case insensitive matching and lookahead for conditional patterns.

Build a sanitizer that validates and cleans user input using multiple regex patterns.

Demonstrates how inner functions access outer function variables through lexical scope.

Creates a counter using closure to maintain private state across function calls.

Shows the common closure mistake in loops and demonstrates the fix using IIFE.

Creates a function that executes only once then returns cached result on subsequent calls.

Transforms a multi-argument function into a sequence of single-argument functions using closures.

Pre-fills some arguments of a function and returns a new function expecting remaining arguments.

Uses IIFE and closures to create a module with private variables and public methods.

Implements function memoization using closure to cache expensive computation results for repeated calls.

Creates multiple independent counters each with private state and increment decrement reset methods.

Mini-project combining module pattern memoization and closures to limit function execution rate across multiple functions.

Pass a function to another function and execute it.

Create a function that returns customized functions based on parameters.

Implement a custom map function that transforms array elements.

Build a filter function that selects elements matching a predicate.

Combine multiple functions into a single composed function.

Chain functions left-to-right with a pipe utility.

Create a tap function that logs values without breaking the chain.

Delay function execution until after a pause in calls.

Limit function execution to once per time period.

Build a mini-project combining pipe, tap, custom filter, and function factories.

Show how this references the object when calling a method.

Demonstrate this becoming undefined when a method is extracted and called standalone.

Show arrow functions inherit this from surrounding scope not the caller.

Use call and apply to explicitly set this when invoking functions.

Create a new function with this permanently bound using bind.

Show this in constructor functions refers to the new instance being created.

Use arrow function class fields to automatically bind this to instances.

Borrow methods from one object to use with another object via call.

Ensure callbacks retain correct this context using bind or arrow functions.

Build a mini event tracking system using bind call apply and arrow functions together.

Demonstrates the prototype chain by creating an object and accessing inherited properties.

Creates objects using a constructor function and demonstrates property assignment.

Defines a class with getter and setter methods to control property access.

Demonstrates static members that belong to the class itself rather than instances.

Shows class inheritance where a child class extends a parent class.

Demonstrates using super to call parent class methods from child class.

Tests object types using instanceof across an inheritance hierarchy.

Implements a mixin to add functionality to classes without inheritance.

Shows polymorphic behavior where different classes respond differently to the same method call.

Mini project combining inheritance, static methods, getters, and polymorphism for task tracking.

Demonstrates simple error catching with try catch blocks.

Shows finally block that executes regardless of errors.

Creates and throws a custom error subclass.

Protects JSON parsing with error handling.

Demonstrates error chaining with cause property.

Handles errors in async functions with try catch.

Implements automatic retry logic for failing operations.

Handles different error types with specific catch logic.

Uses error handling to provide safe fallback values.

Processes user records with validation retry logic and custom errors.

Chain promises to transform data through multiple steps sequentially.

Execute multiple promises concurrently and wait for all to complete.

Handle multiple promises where some succeed and some fail gracefully.

Demonstrate race for fastest completion and any for fastest success.

Compare execution time between sequential and parallel async operations.

Create a reusable timeout wrapper that rejects promises exceeding time limit.

Implement cancellable async operations using a shared cancellation flag object.

Process tasks from a queue with controlled concurrency limit.

Visualize the event loop by showing microtask priority over macrotasks.

Build a mini data pipeline with retry logic timeout and comprehensive error handling.

Implement a simple iterator that returns three numbers.

Create a reusable range object that works with for-of loops.

Use a generator to yield multiple values without manual iterator implementation.

Generate an infinite sequence of Fibonacci numbers using a generator.

Create a take function to limit items from any iterable source.

Use yield star to delegate to another generator or iterable.

Build a unique ID generator with custom prefix and counter.

Create an iterator that fetches paginated data from an array.

Implement a map function that lazily transforms values from an iterable.

Build a state machine using generators to cycle through traffic light states with timing.

Parse a JSON string and stringify an object to JSON.

Use replacer function to filter or transform properties during stringify.

Use reviver function to transform values during parsing.

Clone nested objects using structuredClone and compare with JSON method.

Transform deeply nested object into flat dot-notation keys.

Group array of objects by a specified property value.

Convert array of objects to map keyed by unique identifier.

Transform rows of data into columnar structure by key.

Compare two objects and identify differences at any nesting level.

Parse CSV string to objects then group and normalize data.

Calculate factorial of a number using basic recursion.

Compute Fibonacci numbers efficiently using memoization to cache results.

Recursively sum all numbers in deeply nested arrays.

Search for a key recursively in nested objects and return its value.

Traverse a tree structure recursively and collect all node values.

Generate all permutations of a string using recursion.

Recursively fill connected cells in a grid with a new color.

Search for a target in a sorted array using recursive binary search.

Calculate the maximum depth of a nested menu structure recursively.

Solve Tower of Hanoi puzzle using recursion with move tracking and verification.

Sort an array of numbers in ascending order using the built-in sort method.

Sort objects by a specific property using a custom comparison function.

Sort objects by multiple keys with primary and secondary criteria.

Demonstrate JavaScript sort stability by sorting objects with duplicate keys.

Implement binary search to find an element in a sorted array.

Implement the quicksort algorithm to sort an array of numbers.

Implement the merge sort algorithm with helper merge function.

Count occurrences of each element and display sorted by frequency.

Find the top N largest elements from an array efficiently.

Mini-project combining fuzzy search, multi-key sorting, and top results selection.

Create a stack with push, pop, and peek operations using an array.

Implement a queue with enqueue, dequeue, and front methods using an array.

Build a singly linked list with insert, delete, and display methods.

Create a binary search tree with insert and search operations.

Implement BFS on a binary tree using a queue.

Implement DFS preorder, inorder, and postorder on a binary tree.

Build a hash map using chaining to resolve collisions.

Create a min heap with insert and extract minimum operations.

Represent a graph with adjacency list and perform BFS traversal.

Build a trie for word insertion and prefix-based autocomplete suggestions.

Find two array indices whose values sum to a target number.

Move all zero elements to the end while maintaining order.

Determine if two strings are anagrams of each other.

Split an array into smaller chunks of specified size.

Validate if brackets in a string are properly balanced.

Find the length of longest substring without repeating characters.

Convert matrix rows to columns and columns to rows.

Convert roman numeral string to integer value.

Compress string by encoding consecutive character runs.

Analyzes text combining anagram detection run-length and balanced brackets.

Simple pure functions that always return the same output for the same input.

Using Object.freeze to prevent mutation of state objects.

Using reduce to build complex transformations from simple operations.

Optional pattern to handle null or undefined values safely.

Result type to handle success and failure cases without exceptions.

Compose functions together to create complex transformations from simple ones.

Writing functions without explicitly mentioning their arguments.

Cache function results using WeakMap for automatic garbage collection.

Build data transformation pipelines using reduce for sequential operations.

Mini-project combining pure reducers with immutability and pipeline patterns.

Use setTimeout to print a message after two seconds.

Set a timeout then clear it before execution using clearTimeout.

Use setInterval to print the current time every second for five ticks.

Implement debounce that delays execution until calls stop for specified time.

Implement throttle that ensures function runs at most once per time period.

Poll a simulated resource with exponentially increasing delays between attempts.

Process queued tasks sequentially with delays between each task execution.

Create a countdown from ten to zero with completion message.

Limit function calls to maximum number per time window using token bucket.

Schedule and execute batch jobs with throttling, debounced logging, and progress tracking.

Create a simple event emitter that registers and triggers listeners for named events.

Add a once method that removes listeners after their first execution automatically.

Implement a pub sub system where subscribers filter messages by topic independently.

Create subject and observer classes where observers automatically update on state changes.

Implement command objects with execute and undo methods for reversible operations.

Build a finite state machine that transitions between states with defined rules.

Create an undo redo system that maintains command history with stack operations.

Implement a middleware pipeline that processes requests through sequential handler functions.

Build a plugin registry that loads and manages plugins with lifecycle hooks.

Build a task management system combining event emitters state machine middleware and undo stack.

Create objects using a factory function instead of constructor syntax.

Ensure only one instance of a configuration object exists across the application.

Define application constants and enum-like objects for better code organization.

Pass dependencies to functions instead of hardcoding them for better testability.

Centralize application configuration in a dedicated module with environment support.

Control feature availability using a centralized feature flag system.

Register and retrieve services from a central registry for loose coupling.

Organize code into data repository and business logic service layers.

Group related utilities under namespace objects for organized exports.

Build a mini-project combining factory functions, dependency injection, registry and feature flags.

Use typeof to check and handle different primitive types safely.

Check object types with instanceof to distinguish arrays and dates from plain objects.

Create an assert function to validate conditions and throw on failure.

Use a switch with a never-reached default to ensure all cases are handled.

Parse JSON safely with fallback defaults when input is invalid.

Apply default values and coerce types to ensure valid configuration objects.

Validate object shapes manually by checking required fields and their types.

Check if objects implement required methods rather than specific types.

Create tagged wrappers to distinguish between similar primitives at runtime.

Build a mini-project validating orders with schema checks, branded types, and invariants.

Store a username in localStorage and retrieve it on next run.

Add items to a sessionStorage cart and display the total count.

Build a query string from parameters using URLSearchParams.

Parse a URL and extract hostname, pathname, and query parameters.

Parse a cookie string into key-value pairs as an object.

Encode a message to base64 and decode it back.

Store versioned JSON data in localStorage to handle schema changes.

Store cache entries with expiration times and check validity.

Simulate browser history state management with push and serialization.

Build a storage manager with versioning, expiration, and URL state sync.

Format numbers with thousand separators using the Intl.NumberFormat API.

Display numbers as currency in different locales with proper symbols.

Select correct plural forms for different quantities using Intl.PluralRules.

Display time differences in human readable relative format like ago or in.

Convert text into URL friendly slugs by replacing spaces and special characters.

Shorten long strings to a maximum length and append ellipsis character.

Break long text into multiple lines at specified maximum character width.

Mark all occurrences of a search term in text with brackets.

Replace placeholders in template strings with actual values from data object.

Combine formatting techniques to generate rich blog post preview cards with metadata.

Cache expensive Fibonacci calculations to avoid redundant computation.

Search array stopping immediately when target found instead of scanning all.

Compare Set has method versus array includes for membership testing performance.

Use object property access instead of array find for faster lookups.

Build large strings efficiently with array join versus repeated concatenation.

Defer expensive object creation until first use with lazy getter.

Group multiple operations into single batch for better performance.

Reuse objects from pool instead of creating new ones repeatedly.

Store computed values to avoid recalculating expensive transformations.

Combine memoization batching and efficient lookups for game leaderboard system.

Retrieve nested object values using dot notation path strings.

Set nested object values using dot notation path strings.

Generate RFC4122 compliant universally unique identifiers version 4.

Select random elements from arrays with optional weighted probabilities.

Randomize array element order using Fisher-Yates shuffle algorithm.

Generate numeric ranges and constrain values within bounds.

Execute async operations with exponential backoff retry logic.

Split arrays into smaller chunks for batch processing.

Compare objects and arrays for structural and value equality.

Mini-project combining debounce deep paths shuffle and retry for activity logging.

Track expenses and calculate total spending across categories.

Run a multiple-choice quiz and display the final score.

Add items to cart and apply percentage-based discount codes.

Record deposits and withdrawals with running balance tracking.

Manage product stock with add, remove, and restock operations.

Schedule flashcards with spaced repetition based on user performance.

Play tic-tac-toe and detect winner or draw conditions.

Generate short codes for URLs and retrieve original links.

Implement a state store with subscriptions and state updates.

Manage todos with event emitters for add, complete, and delete actions.

Reverses the order of words in a sentence using array methods.

Finds the first character in a string that does not repeat.

Identifies the element appearing more than half the time using Boyer-Moore voting.

Finds the missing number in a sequence from zero to n.

Combines overlapping time intervals into minimal non-overlapping set.

Validates if brackets are properly opened and closed using a stack.

Calculates product of all array elements except current index without division.

Finds contiguous subarray with largest sum using Kadane's algorithm.

Rotates a square matrix clockwise by ninety degrees in place.

Analyzes text input applying multiple algorithms to extract statistics and patterns.