📘 What are Naming Rules in JavaScript?
JavaScript naming rules are the fundamental guidelines that determine how you can name variables, functions, classes, and other identifiers in your code. Understanding these rules is essential for writing valid JavaScript code that runs without syntax errors. In this comprehensive guide, we'll explore the core naming rules with practical code examples showing what's valid (true) and invalid (false).
Why JavaScript Naming Rules Matter in 2025: • Code Quality: Proper naming prevents syntax errors and improves code maintainability • Team Collaboration: Consistent naming conventions help development teams work efficiently • SEO Benefits: Well-structured code with clear naming improves search engine understanding • Performance: Clean code runs faster and is easier to optimize • Career Growth: Mastering naming rules is a fundamental skill for JavaScript developers
Quick Overview: JavaScript identifiers must follow specific syntax rules, avoid reserved words, and ideally follow community conventions for readability.
📋 JavaScript Naming Rules: Quick Reference Guide
1
2
3
4
5
6
1. Start with a letter (a-z, A-Z), underscore (_), or dollar sign ($)
2. Subsequent characters can be letters, numbers (0-9), underscores, or dollar signs
3. Cannot use hyphens (-), spaces, or special characters
4. Case sensitive (e.g., 'name' and 'Name' are different)
5. Cannot be a reserved word (e.g., if, else, function, class)
6. Must be unique within the same scope (global, function, block)Naming Conventions: Quick Reference Guide
1
2
3
4
5
6
1. Use camelCase for variables and functions (e.g., myVariable)
2. Use PascalCase for classes and constructors (e.g., MyClass)
3. Use UPPER_SNAKE_CASE for constants (e.g., MAX_VALUE)
4. Keep names descriptive and concise
5. Avoid using abbreviations or acronyms
6. Follow team or project-specific naming guidelines📋 JavaScript Naming Rules: Complete List with Code Examples
Here are the essential naming rules in JavaScript, each with code examples showing valid (✅ True) and invalid (❌ False) usage:
1. Identifiers Must Start with Valid Characters • Rule: Names must begin with a letter (a-z, A-Z), underscore (_), or dollar sign ($) • Cannot start with: Numbers or special characters
✅ Valid Examples:
1
2
3
let name = 'John'; // Starts with letter
let _private = 'secret'; // Starts with underscore
let $element = 'div'; // Starts with dollar sign❌ Invalid Examples:
1
2
3
let 123name = 'John'; // SyntaxError: Cannot start with number
let @email = 'test'; // SyntaxError: Invalid character
let #hash = 'value'; // SyntaxError: Invalid character2. Subsequent Characters Must Be Valid • Rule: After the first character, you can use letters, numbers, underscores, and dollar signs • Cannot use: Hyphens, spaces, or other special characters
✅ Valid Examples:
1
2
3
let userName = 'Alice'; // Letters and numbers
let total_count = 100; // Underscore allowed
let price$USD = 50; // Dollar sign allowed❌ Invalid Examples:
1
2
3
let user-name = 'Alice'; // SyntaxError: Hyphen not allowed
let total count = 100; // SyntaxError: Space not allowed
let price@USD = 50; // SyntaxError: @ not allowed3. JavaScript is Case Sensitive • Rule: 'name', 'Name', and 'NAME' are treated as different identifiers • Best Practice: Be consistent with casing throughout your codebase
✅ Valid Examples:
1
2
3
4
5
6
7
let firstName = 'John';
let FirstName = 'Jane'; // Different variable
let FIRSTNAME = 'Bob'; // Different variable
console.log(firstName); // 'John'
console.log(FirstName); // 'Jane'
console.log(FIRSTNAME); // 'Bob'❌ Invalid Examples (would cause confusion):
(Note: These are not syntax errors, but demonstrate why case sensitivity requires careful attention)
1
2
3
4
// These are different variables, not errors, but confusing:
let name = 'John';
let Name = 'Jane'; // Different from 'name'
let NAME = 'Bob'; // Different from both above4. Reserved Words Cannot Be Used • Rule: JavaScript keywords cannot be used as identifiers • Common reserved words: if, else, function, class, var, let, const, return, new, this
✅ Valid Examples:
1
2
3
let userClass = 'student'; // 'class' is reserved, use variation
let returnValue = 42; // 'return' is reserved, use variation
let newObject = {}; // 'new' is reserved, use variation❌ Invalid Examples:
1
2
3
let class = 'student'; // SyntaxError: 'class' is reserved
let return = 42; // SyntaxError: 'return' is reserved
let new = {}; // SyntaxError: 'new' is reserved5. Names Must Be Unique Within Scope • Rule: Cannot declare the same name twice in the same scope • Scope levels: Global, function, block (with let/const)
✅ Valid Examples:
1
2
3
4
5
6
7
8
9
let name = 'John'; // Global scope
function greet() {
let name = 'Jane'; // Function scope - different from global
console.log(name); // 'Jane'
}
greet();
console.log(name); // 'John'❌ Invalid Examples:
1
2
3
4
5
6
7
let name = 'John';
let name = 'Jane'; // SyntaxError: 'name' already declared
function test() {
var x = 1;
var x = 2; // SyntaxError: 'x' already declared
}6. Length Limitations Apply • Rule: No theoretical limit, but practical limits exist • Best Practice: Keep names descriptive but not excessively long
✅ Valid Examples:
1
2
3
let n = 5; // Short but clear in context
let user = 'John'; // Concise and clear
let userAuthenticationStatus = true; // Descriptive❌ Invalid Examples (not errors, but poor practice):
(Note: These are not syntax errors, but demonstrate poor naming practices)
1
2
3
let aVeryLongVariableNameThatIsHardToReadAndType = 'value'; // Too long
let x = 'John'; // Not descriptive
let temp = calculateTotal(); // Vague purpose7. Unicode Characters Are Supported • Rule: Modern JavaScript supports Unicode characters in identifiers • Use Case: International development or mathematical symbols
✅ Valid Examples:
1
2
3
let π = 3.14159; // Greek letter
let café = 'coffee'; // Accented character
let 用户名 = 'username'; // Chinese characters❌ Invalid Examples (older JavaScript):
(Note: These would cause errors in ES5 and earlier JavaScript engines)
1
2
3
// In ES5 and earlier, these would be invalid:
let π = 3.14159; // Would cause error in old browsers
let café = 'coffee'; // Would cause error in old browsers🚫 Reserved Keywords in JavaScript (2025 Update)
JavaScript has an extensive list of reserved words that cannot be used as identifiers. As of ES2024, here are the key reserved words:
Control Flow Keywords: • if, else, switch, case, default, for, while, do, break, continue
Declaration Keywords: • var, let, const, function, class, interface, type, enum
Object & Context Keywords: • this, super, new, typeof, instanceof, in, delete
Error Handling: • try, catch, finally, throw
Modules & Imports: • import, export, from, as, default
Async Programming: • async, await, yield
Other Reserved Words: • return, void, null, undefined, true, false, with, debugger
Future Reserved Words (use with caution): • implements, package, protected, static, public, private
Workarounds for Reserved Words:
1
2
3
4
5
// ✅ Valid alternatives:
let className = 'student'; // Instead of 'class'
let returnValue = 42; // Instead of 'return'
let newInstance = {}; // Instead of 'new'
let defaultValue = 'test'; // Instead of 'default'🏗️ Naming Conventions in JavaScript
While syntax rules are mandatory, naming conventions are community standards that make code more readable:
camelCase Convention (Most Common): • Used for: Variables, functions, methods, properties • Pattern: first word lowercase, subsequent words capitalized • Examples:
1
2
3
let userName = 'John';
function calculateTotal() { ... }
const getUserData = () => { ... };PascalCase Convention: • Used for: Classes, constructors, React components, types • Pattern: All words capitalized • Examples:
1
2
3
class UserAccount { ... }
function Person(name) { ... }
const LoginForm = () => { ... };snake_case Convention: • Used for: Some constants, Python-style code • Pattern: Words separated by underscores, all lowercase • Examples:
1
2
const max_users = 100;
const api_endpoint = '/api';UPPER_CASE Convention: • Used for: True constants that never change • Pattern: All uppercase, words separated by underscores • Examples:
1
2
3
const PI = 3.14159;
const MAX_RETRY_COUNT = 3;
const API_BASE_URL = 'https://api.example.com';✅ Best Practices for JavaScript Naming (2025)
SEO & Performance Benefits: • Descriptive Names: Use names that clearly indicate purpose • Consistent Conventions: Follow one style guide per project • English Language: Use English for international teams • Avoid Abbreviations: Use full words unless universally understood • Length Balance: Neither too short nor excessively long
Code Quality Tips: • Boolean Names: Use is, has, can, should prefixes
1
2
3
let isLoggedIn = true;
let hasPermission = false;
let canEdit = true;• Array Names: Use plural forms
1
2
let users = ['John', 'Jane'];
let userList = [];• Function Names: Use verbs for actions
1
2
3
function getUser() { ... }
function calculateTotal() { ... }
function validateInput() { ... }• Constant Names: Use UPPER_CASE for true constants
1
2
const MAX_USERS = 1000;
const DEFAULT_TIMEOUT = 5000;🧪 Testing Your Knowledge: Naming Rules Quiz
Question 1: Which of these are valid JavaScript identifiers?
1
2
3
4
5
6
✅ let userName = 'valid';
✅ let _private = 'valid';
✅ let $element = 'valid';
❌ let 123invalid = 'invalid';
❌ let my-variable = 'invalid';
❌ let class = 'invalid';Question 2: What naming convention should you use?
1
2
3
4
5
6
7
8
9
10
// Variables and functions: camelCase
let getUserData = () => { ... };
function calculateTotal() { ... };
// Classes: PascalCase
class UserAccount { ... };
const LoginForm = () => { ... };
// Constants: UPPER_CASE
const MAX_RETRIES = 3;🎯 Key Takeaways: JavaScript Naming Rules
• 7 Core Rules: Start characters, subsequent characters, case sensitivity, reserved words, uniqueness, length, Unicode support • True/False Examples: Each rule includes valid and invalid code examples • Syntax Errors: Violating rules causes JavaScript engine errors • Conventions Matter: camelCase, PascalCase, UPPER_CASE improve readability • Best Practices: Descriptive, consistent, English names for better code • 2025 Updates: Modern JavaScript supports Unicode and has expanded reserved words
Mastering JavaScript naming rules is essential for writing clean, error-free code that performs well and ranks better in search engines.
📚 Resources and Further Reading
• MDN Web Docs: JavaScript Identifiers • ECMAScript Specification: Official Language Specification • Airbnb Style Guide: JavaScript Naming Conventions • ESLint: Automated Code Linting • Clean Code Book: Robert C. Martin - Principles of Clean Naming
About the Author: Zeeshan Ali is a senior JavaScript developer with 5+ years of experience in modern web development. Specializing in React, Node.js, and clean code practices. Connect on LinkedIn for more JavaScript insights.
