RuneHub
Tech Trends
RuneAI
RuneHub
Programming Education Platform

Master programming through interactive tutorials, hands-on projects, and personalized learning paths designed for every skill level.

Stay Updated

Learning Tracks

  • Programming Languages
  • Web Development
  • Data Structures & Algorithms
  • Backend Development

Practice

  • Interview Prep
  • Interactive Quizzes
  • Flashcards
  • Learning Roadmaps

Resources

  • Tutorials
  • Tech Trends
  • Search
  • RuneAI

Support

  • FAQ
  • About Us
  • Privacy Policy
  • Terms of Service
  • System Status
© 2026 RuneAI. All rights reserved.
RuneHub
Tech Trends
RuneAI
RuneHub
Programming Education Platform

Master programming through interactive tutorials, hands-on projects, and personalized learning paths designed for every skill level.

Stay Updated

Learning Tracks

  • Programming Languages
  • Web Development
  • Data Structures & Algorithms
  • Backend Development

Practice

  • Interview Prep
  • Interactive Quizzes
  • Flashcards
  • Learning Roadmaps

Resources

  • Tutorials
  • Tech Trends
  • Search
  • RuneAI

Support

  • FAQ
  • About Us
  • Privacy Policy
  • Terms of Service
  • System Status
© 2026 RuneAI. All rights reserved.
RuneHub
Tech Trends
RuneAI
RuneHub
Programming Education Platform

Master programming through interactive tutorials, hands-on projects, and personalized learning paths designed for every skill level.

Stay Updated

Learning Tracks

  • Programming Languages
  • Web Development
  • Data Structures & Algorithms
  • Backend Development

Practice

  • Interview Prep
  • Interactive Quizzes
  • Flashcards
  • Learning Roadmaps

Resources

  • Tutorials
  • Tech Trends
  • Search
  • RuneAI

Support

  • FAQ
  • About Us
  • Privacy Policy
  • Terms of Service
  • System Status
© 2026 RuneAI. All rights reserved.
RuneHub
Tech Trends
RuneAI

Programming Languages

1 topic · 323 articles

    • What is JavaScript? A Complete Beginner Guide
    • What is JavaScript Used For in Web Development
    • Is JavaScript Frontend or Backend? Full Guide
    • JavaScript vs Java: Core Differences Explained
    • How to Start Coding in JavaScript for Beginners
    • The Complete History of JavaScript Explained
    • Who Invented JavaScript? The Brendan Eich Story
    • How JavaScript Evolved from ES1 to Modern ES6+
    • The History of ECMAScript and JavaScript Guide
    • How JavaScript Works in the Browser Explained
    • What is a JavaScript Engine? A Complete Guide
    • How Browsers Read and Execute JavaScript Code
    • How to Run JavaScript in the Browser and Node
    • How to Execute JavaScript in Chrome DevTools
    • Deploying JS Apps Free with GitHub Student Plan
    • JS Variables Guide: How to Declare and Use Them
    • JavaScript Variable Naming Conventions & Rules
    • Global vs Local Variables in JavaScript Guide
    • var vs let vs const: JS Variable Declarations
    • Why You Should Stop Using var in JavaScript
    • When to Use let vs const in Modern JavaScript
    • JavaScript Data Types: A Complete Beginner Guide
    • What are Dynamic Data Types in JavaScript?
    • Primitive vs Reference Types in JS: Full Guide
    • How JavaScript Stores Primitive Values in Memory
    • JavaScript Type Conversion & Coercion Explained
    • JavaScript Implicit vs Explicit Type Conversion
    • Guide to JavaScript Template Literals & Strings
    • Creating Multi-Line Strings in JS With Backticks
    • JS Operators: Arithmetic, Logical & Comparison
    • JavaScript Operator Precedence: Complete Guide with Examples
    • How to Use the typeof Operator in JavaScript: Full Guide
    • What is NaN in JavaScript? A Complete Not a Number Guide
    • How to Check for NaN in JavaScript Using isNaN() Function
    • Undefined vs Null in JavaScript: Key Differences Explained
    • Why You Should Never Assign Undefined in JavaScript Code
    • How to Write Single and Multi-Line Comments in JavaScript
    • JavaScript Commenting Best Practices Every Coder Should Know
    • JavaScript Semicolons: Are They Required? A Complete Guide
    • Automatic Semicolon Insertion (ASI) in JavaScript Explained
    • JavaScript Strict Mode ('use strict') Explained
    • Common Errors Caught by JavaScript Strict Mode
    • JavaScript Console Methods: log, warn & errors
    • Grouping Logs Together with console.group() JS
    • Basic JavaScript Debugging Tips for Beginners
    • How to Read and Understand JavaScript Stack Traces
    • JavaScript If Statement: A Complete Beginner Guide
    • How to Write If Else Statements in JS: Full Guide
    • JavaScript Else If: Chaining Multiple Conditions
    • JS Switch Statement vs If Else: Which is Better?
    • How to Use the JavaScript Switch Case Full Guide
    • JavaScript Ternary Operator: Complete Syntax Guide
    • Chaining Ternary Operators in JavaScript Tutorial
    • JS For Loop Syntax: A Complete Guide for Beginners
    • How to Loop Through Arrays using JS For Loops Guide
    • JavaScript While Loop Explained: A Complete Guide
    • How to Avoid Infinite Loops in JS: Full Tutorial
    • JS Do-While Loop: Syntax and Practical Use Cases
    • JavaScript Break Statement: Exiting Loops Early
    • JavaScript Continue Statement: Skipping Iterations
    • How to Write Nested Loops in JavaScript: Tutorial
    • Optimizing JavaScript Loops for Fast Performance
    • What are Truthy and Falsy Values in JavaScript?
    • JavaScript Logical Short-Circuiting Complete Guide
    • What is a Function in JavaScript? Beginner Guide
    • How to Declare and Call a JavaScript Function
    • JavaScript Function Expressions vs Declarations
    • JavaScript Arrow Functions: A Complete ES6 Guide
    • When to Avoid Using Arrow Functions in JavaScript
    • JS Function Parameters vs Arguments: Differences
    • How to Use Default Parameters in JS Functions
    • JavaScript Rest Parameters: A Complete Tutorial
    • What is a Callback Function in JS? Full Tutorial
    • How to Pass a Function as an Argument in JS Guide
    • Pure vs Impure Functions in JavaScript Explained
    • Writing Pure Functions in JS: A Complete Tutorial
    • JavaScript IIFE: Immediately Invoked Functions
    • How to Use Recursion in JavaScript: Full Tutorial
    • Preventing Stack Overflow in JavaScript Recursion
    • Higher-Order Functions in JavaScript: Full Guide
    • Returning Functions from Functions in JavaScript
    • JavaScript Function Scope: Local vs Global Scope
    • Understanding JavaScript Hoisting for Beginners
    • JavaScript Execution Context: A Complete Tutorial
    • What is an Array in JavaScript? A Complete Guide
    • How to Create and Initialize JavaScript Arrays
    • Accessing and Modifying JS Array Elements Guide
    • JS Array Push and Pop Methods: A Complete Guide
    • JS Array Shift and Unshift Methods: Full Tutorial
    • JavaScript Array Slice Method: A Complete Guide
    • JavaScript Array Splice Method: Complete Tutorial
    • JS Array Slice vs Splice: What is the Difference?
    • How to Use the JavaScript Array Map Method Today
    • JavaScript Array Filter Method: Complete Tutorial
    • Using the JavaScript Array Reduce Method Guide
    • JavaScript Array forEach Loop: Complete Tutorial
    • JS Array Map vs forEach: Which Should You Use?
    • JavaScript Array Find and findIndex Methods Guide
    • JS Array Some and Every Methods: Complete Guide
    • How to Sort Arrays in JavaScript: Complete Guide
    • Sorting Numbers Correctly in JS Arrays Tutorial
    • JS Array Flat Method: Flatten Nested Arrays Fast
    • JavaScript Array flatMap Method: Complete Guide
    • JavaScript Array Destructuring: Complete Tutorial
    • JavaScript Functions Explained: From Basic to Advanced Concepts
    • JavaScript Loops Tutorial: for, while & do-while
    • JavaScript Conditional Statements: if, else & switch Guide
    • Learn JavaScript Step by Step Tutorial with Real Examples
    • JavaScript Objects & Arrays: Complete Tutorial
    • JS Spread Operator for Arrays: Complete Tutorial
    • How to Merge Two Arrays in JavaScript Full Guide
    • Removing Duplicates from JavaScript Arrays Guide
    • Top JS Array Methods Interview Questions to Know
    • What is an Object in JavaScript? Beginner Guide
    • How to Create Objects in JavaScript: Full Guide
    • Accessing Object Properties in JS: Full Tutorial
    • JS Objects: Dot Notation vs Bracket Notation
    • Adding and Deleting Properties in JS Objects
    • JavaScript Object Methods: A Complete Tutorial
    • The 'this' Keyword in JavaScript Objects Guide
    • JavaScript Object Destructuring Complete Guide
    • Renaming Variables in JS Object Destructuring
    • How to Use Object.assign in JavaScript Properly
    • JS Object Keys, Values, and Entries Full Guide
    • How to Loop Through a JavaScript Object Tutorial
    • JS Optional Chaining (?.) Syntax Complete Guide
    • JS Nullish Coalescing Operator (??) Full Guide
    • How to Clone a JavaScript Object Without Errors
    • Shallow Copy vs Deep Copy in JavaScript Objects
    • What is the DOM in JavaScript? A Beginner Guide
    • Understanding the HTML DOM Tree Structure Guide
    • Selecting DOM Elements in JavaScript Full Guide
    • How to Use JS querySelector and querySelectorAll
    • How to Use getElementById in JS: Complete Guide
    • JS getElementsByClassName vs querySelector Guide
    • How to Change Text Content Using JavaScript DOM
    • innerText vs textContent in JavaScript Explained
    • Using innerHTML Safely in JavaScript DOM Methods
    • Changing CSS Styles with JavaScript DOM Methods
    • Building Beautiful JS UIs with Inter & Outfit
    • Adding and Removing CSS Classes with JavaScript
    • How to Use classList toggle in JavaScript DOM
    • Creating HTML Elements with JavaScript DOM Guide
    • Appending Elements to the DOM in JS: Full Guide
    • Removing HTML Elements Using JavaScript Methods
    • How to Add Event Listeners in JS: Complete Guide
    • Handling Click Events in JavaScript: Full Guide
    • JavaScript Keyboard Events: keyup and keydown
    • JavaScript Event Bubbling Explained for Beginners
    • JavaScript Event Delegation: Complete Tutorial
    • Using preventDefault() in JavaScript Full Guide
    • JavaScript Form Handling and Submission Tutorial
    • Basic Form Validation with JavaScript Tutorial
    • Build a JavaScript Todo App: Beginner DOM Project
    • Build a JS Counter App: Beginner DOM Mini Project
    • Build a JS Calculator: Beginner DOM Mini Project
    • JavaScript Closures Deep Dive: Complete Guide
    • Practical Use Cases for JS Closures in Real Apps
    • How to Prevent Memory Leaks in JavaScript Closures
    • JavaScript Lexical Scope: A Complete Tutorial
    • How Lexical Environment Works in JavaScript
    • JS Execution Context Deep Dive: Full Tutorial
    • Understanding the JavaScript Call Stack Guide
    • How the JS Call Stack Handles Function Execution
    • JavaScript setTimeout Behavior: Complete Guide
    • How setInterval Works in JavaScript: Architecture
    • Clearing Timeouts and Intervals in JavaScript
    • The JavaScript Event Loop Explained in Detail
    • JS Microtasks vs Macrotasks: A Complete Guide
    • JavaScript Callbacks vs Promises: Full Tutorial
    • Avoiding Callback Hell in JavaScript: Complete Tutorial
    • JavaScript Promise Chaining: A Complete Guide
    • How to Handle Promise Rejections in JavaScript
    • How to Use Promise.all in JavaScript: Complete Tutorial
    • Using Promise.allSettled for Reliable JavaScript APIs
    • How to Use Promise.race in JavaScript: Complete Guide
    • JavaScript async/await: Complete Tutorial Guide
    • Converting Promises to async/await in JavaScript
    • JavaScript try/catch Tutorial: Advanced Error Handling
    • Handling Async Errors With try/catch in JavaScript
    • Creating Custom Errors in JavaScript: Complete Tutorial
    • Extending the JavaScript Error Class: Full Guide
    • The JavaScript Prototype Chain: Complete Guide
    • JavaScript __proto__ vs prototype: What Is the Difference?
    • How Prototypal Inheritance Works in JavaScript
    • Modifying the JavaScript Object Prototype: Guide
    • JS Constructor Functions: A Complete Tutorial
    • JavaScript Classes Explained: Complete Tutorial
    • JavaScript Class Inheritance: Complete Tutorial
    • Using the super Keyword in JavaScript Classes
    • JavaScript Static Methods: A Complete Tutorial
    • Encapsulation in JavaScript: Complete Tutorial
    • Creating Private Class Fields in Modern JS
    • Polymorphism in JavaScript: Complete Tutorial
    • The JavaScript this Keyword: Full Deep Dive
    • How Arrow Functions Change this in JavaScript
    • Losing this in JavaScript Callbacks Explained
    • JS bind, call, and apply Methods: Full Tutorial
    • When to Use JS bind vs call vs apply: Full Guide
    • JS let vs const: An Advanced Memory Deep Dive
    • Advanced Arrow Functions in JS: Complete Guide
    • Returning Objects from JS Arrow Functions Guide
    • Advanced Array and Object Destructuring Guide
    • Renaming Variables During JS Destructuring Guide
    • JS Spread vs Rest Operator Complete Tutorial
    • Copying Nested Objects With the JS Spread Operator
    • JavaScript ES6 Modules Import Export Guide
    • JavaScript Default Exports Complete Tutorial
    • JavaScript Named Exports a Complete Tutorial
    • Dynamic Imports in JavaScript Complete Guide
    • Advanced JS Optional Chaining Complete Guide
    • Advanced JS Nullish Coalescing Full Tutorial
    • Logical Assignment Operators in JS Complete Guide
    • Deploying JS Modules Using the GitHub Student Plan
    • JavaScript Tagged Template Literals Deep Dive
    • Building Custom JS String Parsers Full Tutorial
    • The JS Event Loop Architecture Complete Guide
    • Browser Web APIs in JavaScript Complete Guide
    • How to Use the JS Fetch API Complete Tutorial
    • Handling POST Requests With JS Fetch API Guide
    • Uploading Files via JS Fetch API Complete Guide
    • Building a Dynamic JS Portfolio at Parthh.in
    • How to Use Axios in JavaScript: Complete Guide
    • Axios Interceptors in JavaScript: Complete Guide
    • Advanced API Error Handling in JS: Full Guide
    • Debouncing in JavaScript: A Complete Tutorial
    • Building a Search Bar with JS Debouncing Guide
    • Throttling in JavaScript: A Complete Tutorial
    • Scroll Event Throttling in JavaScript: Full Guide
    • Rate Limiting in JavaScript: Complete Tutorial
    • Advanced JS Promise Patterns: Complete Tutorial
    • API Retry Patterns in JavaScript: Full Tutorial
    • Using AbortController in JS: Complete Tutorial
    • Canceling Fetch Requests in JavaScript Full Guide
    • JavaScript Web Streams API: A Complete Tutorial
    • JavaScript Async Generators: Complete Tutorial
    • JS LocalStorage API Guide: A Complete Tutorial
    • Storing Complex Objects in JS LocalStorage Guide
    • JS SessionStorage API Guide: Complete Tutorial
    • How to Manage Cookies in JS: Complete Tutorial
    • Parsing and Deleting Browser Cookies With JS
    • JS Geolocation API Guide: A Complete Tutorial
    • Tracking User Location With JavaScript Geolocation
    • JavaScript Clipboard API: A Complete Tutorial
    • Building a Copy to Clipboard Button in JavaScript
    • JavaScript History API Guide: Complete Tutorial
    • Creating an SPA Router With the JS History API
    • JS Intersection Observer API: Complete Tutorial
    • Implementing Infinite Scroll with JS Observers
    • JavaScript Mutation Observer: Complete Tutorial
    • Tracking DOM Changes with JS Mutation Observers
    • JavaScript Notifications API: Complete Tutorial
    • Requesting Desktop Notification Permissions in JS
    • The Web Storage API: Local vs Session Storage
    • Using the Web Audio API in JavaScript Full Guide
    • Fixing JavaScript Memory Leaks: Complete Guide
    • How to Find and Fix Memory Leaks in JavaScript
    • Identifying Detached DOM Elements in JavaScript
    • JavaScript Garbage Collection Complete Guide
    • How V8 Garbage Collector Works in JavaScript
    • Mark-and-Sweep Algorithm in JS: Full Tutorial
    • JavaScript Profiling: Advanced Performance Guide
    • Using Chrome DevTools for JS Performance Tuning
    • How to Measure JavaScript Execution Time Accurately
    • JS Code Splitting: Advanced Performance Guide
    • Implementing Route-Level Code Splitting in JS
    • Lazy Loading in JavaScript: Complete Tutorial
    • How to Lazy Load Images and Components in JS
    • JavaScript Tree Shaking: A Complete Tutorial
    • Removing Dead Code with JS Tree Shaking Guide
    • JavaScript Bundlers: An Advanced Architecture
    • Webpack vs Vite vs Rollup: JS Bundler Guide
    • Optimizing JavaScript for Core Web Vitals Guide
    • Minifying and Uglifying JavaScript Code for Production
    • JavaScript Module Pattern: Advanced Tutorial
    • Implementing the Revealing Module Pattern JS
    • JavaScript Singleton Pattern: Complete Guide
    • When to Use the Singleton Pattern in JS Apps
    • JavaScript Observer Pattern: Complete Guide
    • Building a Reactive UI with the JS Observer
    • The JavaScript Factory Pattern: Complete Guide
    • Creating Dynamic Objects with JS Factory Pattern
    • JavaScript Strategy Pattern: Complete Guide
    • The JavaScript Proxy Pattern: Complete Guide
    • JavaScript Decorator Pattern: Complete Guide
    • Using Decorators for Logging in JS Architecture
    • The JavaScript Pub/Sub Pattern: Complete Guide
    • Building an Event Bus with JS Pub/Sub Pattern
    • JavaScript MVC Architecture: Complete Guide
    • Building Vanilla JS Apps with MVC Architecture
    • Vanilla JS State Management for Advanced Apps
    • Building Enterprise UI Systems in Vanilla JS
    • JavaScript V8 Engine Internals: Complete Guide
    • How the Google V8 Engine Compiles JavaScript
    • JavaScript Parsing and Compilation: Full Guide
    • Abstract Syntax Trees (AST) in JavaScript Guide
    • V8 Hidden Classes in JavaScript: Full Tutorial
    • Optimizing JS Object Creation for V8 Engine
    • JavaScript Inline Caching: A Complete Tutorial
    • JavaScript Bytecode Explained: Complete Guide
    • Ignition Interpreter and JS Bytecode Tutorial
    • JavaScript JIT Compilation Advanced Tutorial
    • TurboFan Compiler and JS Optimization Guide
    • JavaScript Event Loop Internals Full Guide
    • Understanding libuv and JS Asynchronous I/O
    • Call Stack vs Task Queue vs Microtask Queue in JS
    • Advanced JavaScript Proxies Complete Guide
    • Data Binding with JS Proxies Complete Guide
    • Intercepting Object Calls with JS Proxy Traps
    • JavaScript Reflect API Advanced Architecture
    • Using Reflect and Proxy Together in JavaScript
    • JavaScript WeakMap and WeakSet Complete Guide
    • Preventing Memory Leaks with JS WeakMaps Guide
    • JavaScript Generators Deep Dive Full Guide
    • Handling Async Flows with JS Generator Functions
    • Advanced JavaScript Iterators Complete Guide
    • Creating JavaScript Custom Iterables Full Guide
    • JS Metaprogramming Advanced Architecture Guide
    • Writing Self-Modifying Code in JS Architecture
    • Creating Advanced UI Frameworks in JavaScript
    • JavaScript Macros and Abstract Code Generation
    • Advanced Web Workers for High Performance JS
    • OffscreenCanvas API in JS for UI Performance
Previous
Why You Should Never Assign Undefined in JavaScript Code
8 min · beginner
Next
JavaScript Commenting Best Practices Every Coder Should Know
10 min · beginner
Home/Tutorials/Programming Languages/JavaScript

How to Write Single and Multi-Line Comments in JavaScript

Learn the complete syntax for writing single-line, multi-line, and documentation comments in JavaScript. Understand when to use each type and how comments affect code execution.

JavaScriptbeginner
RuneHub Team
RuneHub Team
February 26, 2026
8 min read
RuneHub Team
RuneHub Team
Feb 26, 2026
8 min read

Comments are lines of text in your JavaScript code that the engine completely ignores during execution. They exist purely for human readers: to explain what the code does, why a particular approach was chosen, or to temporarily disable code during debugging. Every professional codebase uses comments, and knowing the syntax and conventions for writing them is a fundamental skill.

Think of comments as sticky notes attached to your code. The computer never reads them, but every person who opens the file does. A well-placed comment can save an hour of reverse-engineering; a missing comment on a complex algorithm can cost a team days of confusion.

JavaScript supports three styles of comments: single-line, multi-line, and JSDoc documentation blocks. This guide covers the syntax for each, when to use them, and how they interact with code execution.

Single-Line Comments with //

Single-line comments start with two forward slashes (//). Everything after // on that line is ignored by the JavaScript engine:

javascriptjavascript
// This is a single-line comment
const name = "Alice";
 
// Calculate the discount based on membership level
const discount = calculateDiscount(membership);
 
const tax = 0.08; // Tax rate for the current region

Single-line comments work in two positions:

  1. On their own line (above the code they describe)
  2. At the end of a line (inline, after the code)
javascriptjavascript
// Position 1: Above the code (most common)
// Validate that the user has an active subscription before proceeding
if (user.subscription.status === "active") {
  grantAccess(user);
}
 
// Position 2: End of line (for brief clarifications)
const MAX_RETRIES = 3; // Matches the API gateway timeout policy
const TIMEOUT_MS = 5000; // 5 seconds

What Happens During Execution

The JavaScript engine strips comments during the parsing phase, before any code runs. Comments have zero impact on performance:

javascriptjavascript
// This comment does not slow down your code
const x = 10; // Neither does this one
// Even a thousand comments have zero runtime cost
const y = 20;

Multi-Line Comments with /* */

Multi-line comments start with /* and end with */. Everything between these markers is ignored, even across multiple lines:

javascriptjavascript
/* This is a multi-line comment.
   It can span as many lines as needed.
   The engine ignores everything between the markers. */
const greeting = "Hello, World!";
javascriptjavascript
/*
  Configuration object for the payment gateway.
  All values are loaded from environment variables at startup.
  See docs/payment-setup.md for the full configuration reference.
*/
const paymentConfig = {
  apiKey: process.env.PAYMENT_API_KEY,
  merchantId: process.env.MERCHANT_ID,
  environment: process.env.NODE_ENV === "production" ? "live" : "sandbox"
};

Multi-Line Comment Formatting Conventions

Most codebases follow one of two formatting patterns for multi-line comments:

javascriptjavascript
// Style 1: Stars aligned on the left (most common)
/*
 * Handle the checkout process.
 * Validates the cart, applies discounts,
 * and processes the payment.
 */
function processCheckout(cart) {
  // ...
}
 
// Style 2: No leading stars (simpler)
/*
  Handle the checkout process.
  Validates the cart, applies discounts,
  and processes the payment.
*/
function processCheckout(cart) {
  // ...
}

Both are valid. Choose one and be consistent across your project.

Inline Multi-Line Comments

You can also use /* */ within a single line to comment out part of an expression:

javascriptjavascript
// Comment out one argument for testing
const result = calculate(width, /* height, */ depth);
 
// Temporarily change a value
const environment = /* "production" */ "development";
Multi-Line Comments Cannot Be Nested

JavaScript does not support nested multi-line comments. The first */ the engine encounters closes the comment, even if another /* appeared inside it. This can cause hard-to-find syntax errors when commenting out large blocks of code that already contain multi-line comments.

javascriptjavascript
/* This outer comment starts here
   /* This inner comment seems fine */
   but this text is no longer commented and causes a syntax error
*/

JSDoc Comments for Documentation

JSDoc comments are a special form of multi-line comments that start with /** (two stars after the slash). They are used to document functions, classes, and modules with structured annotations that editors and documentation tools can parse:

javascriptjavascript
/**
 * Calculate the total price including tax and discount.
 * @param {number} subtotal - The pre-tax, pre-discount amount
 * @param {number} taxRate - Tax rate as a decimal (e.g., 0.08 for 8%)
 * @param {number} [discount=0] - Optional discount amount to subtract
 * @returns {number} The final price rounded to 2 decimal places
 */
function calculateTotal(subtotal, taxRate, discount = 0) {
  const taxAmount = subtotal * taxRate;
  const total = subtotal + taxAmount - discount;
  return Math.round(total * 100) / 100;
}

JSDoc comments enable:

  • IntelliSense/autocomplete in editors like VS Code
  • Type checking when using TypeScript or JSDoc type annotations
  • Generated documentation with tools like JSDoc, TypeDoc, or Documentation.js
javascriptjavascript
/**
 * Represents a user in the system.
 * @typedef {Object} User
 * @property {string} name - Display name
 * @property {string} email - Email address
 * @property {string} role - One of "admin", "editor", "viewer"
 * @property {Date} createdAt - Account creation timestamp
 */
 
/**
 * Find a user by their email address.
 * @param {string} email - The email to search for
 * @returns {User|null} The matching user, or null if not found
 */
function findUserByEmail(email) {
  return users.find(u => u.email === email) || null;
}

Comment Types Comparison

FeatureSingle-Line (//)Multi-Line (/* */)JSDoc (/** */)
Spans multiple linesNoYesYes
Can be inlineYesYesRarely
NestableYes (each line)NoNo
Parsed by editorsNoNoYes
Generates docsNoNoYes
Best forQuick notes, TODOsBlock descriptionsFunction/class docs

Using Comments to Disable Code

Comments are frequently used during development to temporarily disable code:

javascriptjavascript
// Disable a single line
// console.log("Debug output:", data);
 
// Disable multiple lines
/*
validateUser(user);
sendNotification(user);
logActivity(user);
*/
 
// Disable part of an expression
const features = {
  darkMode: true,
  // notifications: true,  // Disabled until backend is ready
  analytics: false
};
Use Version Control, Not Comment Blocks

While commenting out code is useful during active development, do not leave large blocks of commented-out code in your committed files. Use Git to preserve old code and delete it from the working file. Commented-out code clutters the file and creates confusion about what is active. See the commenting best practices guide for more on this.

Special Comment Annotations

Several comment annotations have special meaning across JavaScript tools and teams:

javascriptjavascript
// TODO: Implement pagination for the user list
function getUsers() {
  return fetchAllUsers(); // Returns everything for now
}
 
// FIXME: This breaks when the array is empty
function getAverage(numbers) {
  return numbers.reduce((a, b) => a + b) / numbers.length;
}
 
// HACK: Workaround for browser bug in Safari 17
element.style.transform = "translateZ(0)";
 
// NOTE: This timeout matches the server-side session duration
const SESSION_TIMEOUT = 30 * 60 * 1000;
 
// WARNING: Changing this value requires a database migration
const MAX_USERNAME_LENGTH = 50;
 
// @ts-ignore - Suppress TypeScript error on next line
// @ts-expect-error - Expected TypeScript error on next line
AnnotationPurpose
TODOTask that needs to be done later
FIXMEKnown bug that needs fixing
HACKWorkaround that should be replaced
NOTEImportant context for understanding the code
WARNINGCautionary note about side effects or risks
@ts-ignoreSuppress TypeScript error (use sparingly)

Comments in HTML and CSS (Bonus Context)

Since JavaScript often lives alongside HTML and CSS, knowing the comment syntax for all three prevents confusion:

htmlhtml
<!-- This is an HTML comment -->
<script>
  // This is a JavaScript comment inside a script tag
  const x = 10;
</script>
csscss
/* This is a CSS comment */
.container {
  width: 100%; /* Inline CSS comment */
}
LanguageSingle-LineMulti-Line
JavaScript// comment/* comment */
HTMLN/A<!-- comment -->
CSSN/A/* comment */

Where to Place Comments

Strategic comment placement communicates intent without cluttering the code:

javascriptjavascript
// 1. File header: describe the module's purpose
/**
 * User authentication middleware.
 * Validates JWT tokens and attaches the user object to the request.
 * Requires AUTH_SECRET environment variable to be set.
 */
 
// 2. Before complex logic: explain WHY, not WHAT
// Use binary search instead of linear scan because the roster
// is sorted and can contain up to 50,000 entries
const index = binarySearch(roster, targetId);
 
// 3. Before regex patterns: always explain regex
// Match email format: local@domain.tld (RFC 5322 simplified)
const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
 
// 4. Before magic numbers: explain the value
const EARTH_RADIUS_KM = 6371; // Mean radius in kilometers (WGS 84)
 
// 5. Before workarounds: explain the constraint
// Safari does not support the `gap` property in flexbox below v14.1
// Using margin-based spacing as a fallback

Best Practices

Writing Comments That Help

The goal of comments is to make code understandable. These practices ensure your comments add value rather than noise.

Comment the "why," not the "what." If your code is readable, the "what" is already clear. Comments should explain business rules, edge cases, performance decisions, and non-obvious constraints that the code alone cannot communicate.

javascriptjavascript
// Bad: restates the code
// Set count to 0
let count = 0;
 
// Good: explains the reason
// Reset count when switching tabs to prevent stale data accumulation
let count = 0;

Keep comments close to the code they describe. A comment that is separated from its code by blank lines or other statements becomes misleading. When the code changes, the orphaned comment stays and becomes wrong.

Update comments when you change the code. An outdated comment is worse than no comment at all. When refactoring, always check whether nearby comments still apply.

Use JSDoc for all exported functions. Any function that other modules import should have a JSDoc comment documenting its parameters, return value, and any side effects. This generates IntelliSense hints for every developer who uses the function.

Delete commented-out code before committing. Use Git to preserve old code. Commented-out code in committed files creates confusion about what is active and what is dead.

Common Mistakes and How to Avoid Them

Watch Out for These Pitfalls

Bad commenting habits reduce code readability instead of improving it.

Commenting obvious code. Adding // increment i by 1 above i++ wastes screen space and insults the reader. Only comment things that are not immediately obvious from reading the code.

Nesting multi-line comments. /* outer /* inner */ still in outer */ causes a syntax error because the first */ ends the entire comment. If you need to comment out a block that contains /* */ comments, use single-line comments (//) for each line instead.

Using comments instead of better naming. If you need a comment to explain what a variable does, consider renaming the variable instead:

javascriptjavascript
// Bad: needs comment
const d = 30; // days until expiration
 
// Good: self-documenting
const daysUntilExpiration = 30;

Writing comments in inconsistent style. Some files use // comment and others use /* comment */ for the same purpose. Pick a convention (single-line for brief notes, JSDoc for function docs, multi-line for block descriptions) and apply it consistently.

Leaving TODO comments indefinitely. TODO comments should be temporary. If a TODO has been in the codebase for months, either do it or remove it. Use your issue tracker for long-term tasks.

Next Steps

Learn JavaScript commenting best practices

Knowing the syntax is just the beginning. The commenting best practices guide covers when to comment, when not to, and how to write comments that genuinely help your team.

Set up JSDoc in your project

Configure your editor to parse JSDoc comments for IntelliSense. In VS Code, JSDoc works out of the box for JavaScript files. Try adding JSDoc comments to your most complex functions and see the improved autocomplete.

Practice reading code without comments

Open an open-source project on GitHub and read a file with all comments removed. Note which parts confuse you. Those are the spots where comments add real value.

Review your existing comments

Go through a recent project file and evaluate every comment. Does it explain "why"? Is it still accurate? Would better naming eliminate the need for it?

Rune AI

Rune AI

Key Insights

  • Single-line //: best for brief explanations and inline notes; everything after // on that line is ignored
  • Multi-line /* */: best for block descriptions and disabling code; cannot be nested
  • JSDoc /** */: structured documentation parsed by editors; use for exported functions and classes
  • Comment the "why": explain business rules, constraints, and non-obvious decisions, not what the code already says
  • Zero performance cost: comments are stripped during parsing and removed entirely by minifiers in production builds
Powered by Rune AI

Frequently Asked Questions

What is the difference between // and /* */ comments in JavaScript?

The `//` syntax creates a single-line comment that extends from the `//` to the end of that line. The `/* */` syntax creates a multi-line comment that can span any number of lines between the opening `/*` and closing `*/`. Single-line comments are best for brief notes and inline explanations, while multi-line comments are better for block descriptions, file headers, and temporarily disabling multiple lines of code.

Do comments affect JavaScript performance?

No. Comments have zero impact on runtime performance. The JavaScript engine strips all comments during the parsing phase before any code executes. The only overhead is a negligible increase in file size before minification. Build tools like Terser, esbuild, and webpack automatically remove all comments from production bundles.

Can JavaScript comments be nested?

Single-line comments following each other on consecutive lines work fine. However, multi-line `/* */` comments cannot be nested. If you write `/* outer /* inner */ still outer */`, the first `*/` closes the entire comment, and the remaining text causes a syntax error. Use single-line `//` comments for each line if you need to comment out a block that already contains multi-line comments.

What are JSDoc comments and when should I use them?

JSDoc comments start with `/**` and use structured tags like `@param`, `@returns`, and `@typedef` to document functions, classes, and types. Use them for any function, class, or module that will be imported by other files. Editors like VS Code parse JSDoc comments to provide IntelliSense hints, parameter info, and type checking, making your code easier for other developers to use correctly.

Should I leave commented-out code in my files?

No. Commented-out code clutters files and creates confusion about what is active. Use version control (Git) to preserve old code. If you need to reference a previous implementation, check the Git history. The only exception is briefly commenting out code during active debugging, but always remove it before committing.

Conclusion

JavaScript provides three comment styles for different purposes: // for quick single-line notes, /* */ for multi-line descriptions, and /** */ for JSDoc documentation parsed by editors and tooling. The key to effective commenting is explaining why the code exists and why specific decisions were made, not restating what the code does. Keep comments close to the code they describe, update them when the code changes, and always delete commented-out code before committing.

Tags

JavaScriptCode ReadabilityProgramming FundamentalsBeginner JavaScriptJavaScript CommentsCode Documentation
Previous
Why You Should Never Assign Undefined in JavaScript Code
8 min read · beginner
Next
JavaScript Commenting Best Practices Every Coder Should Know
10 min read · beginner

More in this topic

OffscreenCanvas API in JS for UI Performance

Master the OffscreenCanvas API to offload rendering from the main thread. Covers worker-based 2D and WebGL rendering, animation loops inside workers, bitmap transfer, double buffering, chart rendering pipelines, image processing, and performance measurement strategies.

Advanced Web Workers for High Performance JS

Master Web Workers for truly parallel JavaScript execution. Covers dedicated and shared workers, structured cloning, transferable objects, SharedArrayBuffer with Atomics, worker pools, task scheduling, Comlink RPC patterns, module workers, and performance profiling strategies.

JavaScript Macros and Abstract Code Generation

Master JavaScript code generation techniques for compile-time and runtime metaprogramming. Covers AST manipulation, Babel plugin authorship, tagged template literals as macros, code generation pipelines, source-to-source transformation, compile-time evaluation, and safe eval alternatives.

On this page

    Share
    RuneHub
    Programming Education Platform

    Master programming through interactive tutorials, hands-on projects, and personalized learning paths designed for every skill level.

    Stay Updated

    Learning Tracks

    • Programming Languages
    • Web Development
    • Data Structures & Algorithms
    • Backend Development

    Practice

    • Interview Prep
    • Interactive Quizzes
    • Flashcards
    • Learning Roadmaps

    Resources

    • Tutorials
    • Tech Trends
    • Search
    • RuneAI

    Support

    • FAQ
    • About Us
    • Privacy Policy
    • Terms of Service
    • System Status
    © 2026 RuneAI. All rights reserved.