- 01Setting Up (What You'll Need)
- 02Creating Variables
- 03Conditionals (if Statements)
- 04Loops (for Statements)
- 05Creating Functions
- 06Working with Arrays
- 07Working with Objects
- 08Loops (while Statements)
- 09Working with Strings
- 10Using Classes (Object-Oriented Programming)
- 11Error Handling (try...catch)
- 12Destructuring and the Spread Syntax
- 13Async Code (Promise / async & await)
- 14Advanced Array Methods (filter and reduce)
- 15The switch Statement
- 16The Ternary Operator
- 17Inheritance (Extending Classes)
- 18How to Write Comments
- 19Logical Operators (AND, OR, NOT)
- 20Constants (Making Read-Only Values with const)
- 21Splitting and Joining Strings (split and join)
- 22Null-Safe Syntax (?? and ?.)
- 23Searching Arrays and Collections (includes and find)
- 24Transforming Arrays with map
- 25Two-Dimensional Arrays (Table-Shaped Data)
- 26Building a Custom Error Class
- 27Default Arguments (Setting Initial Values for Parameters)
- 28Using Set (Collections)
- 29Verifying Correctness with assert (Your First Step Into Testing)
- 30Higher-Order Functions (Passing a Function as an Argument)
- 31Stacks and Queues (Basic Data Structures)
- 32The Basics of Type Conversion (Casting)
- 33Introduction to Regular Expressions (Pattern Matching)
- 34The Binary Search Algorithm
- 35Building a Caesar Cipher (a Letter-Shifting Cipher)
- 36Understanding How Bubble Sort Works
- 37Building and Displaying Dates (Basic Year/Month/Day Operations)
- 38Writing Several Unit Tests Together (Multiple Test Cases)
- 39Speeding Up Calculations with Memoization (Caching)
- 40Normalizing Strings (trim and Case Unification)
- 41The Difference Between Shallow Copy and Deep Copy
- 42The Basics of Enums (Enumerated Types)
- 43Flattening Arrays (flatten)
- 44Reversing a String and Checking for a Palindrome
- 45Pairing Up Two Arrays (a zip Operation)
- 46Rounding Numbers (floor, ceil, and round)
- 47Multi-Line Strings (Template Literals)
- 48Returning Multiple Values from a Function (Array Destructuring)
- 49Finding the GCD and LCM (the Euclidean Algorithm)
- 50Formatting Numbers (Digit Alignment and Decimal Precision)
- 51Cleanup Processing with try/catch/finally
- 52Writing Type-Agnostic, General-Purpose Functions
- 53The Basics of Map (an Object for Key-Value Pairs)
- 54Generating Random Numbers
- 55Bitwise Operations (AND, OR, XOR, and Shift Operations)
- 56Using static (Static Class Properties and Methods)
- 57Waiting a Fixed Amount of Time (setTimeout and await)
- 58Watch Out for Floating-Point Rounding Error
- 59Transforming and Flattening at Once with flatMap()
- 60FizzBuzz (the Classic Practice Problem)
- 61Checking Whether a Number Is Prime
- 62Set Operations with Set (Union, Intersection, and Difference)
- 63Converting Number Bases (Binary and Hexadecimal)
- 64Checking That Brackets Match (an Application of Stacks)
- 65Checking for an Anagram
- 66Checking Whether a Year Is a Leap Year
- 67Converting Temperature (Celsius ⇄ Fahrenheit)
- 68Finding the Prime Factorization
- 69[Applied] Build a Simple To-Do List Tool
Constants (Making Read-Only Values with const)
In this lesson you'll learn how to make constants in JavaScript using const, so you can prevent accidental value changes and write safer code. This is for people searching "JavaScript const let difference" or "JavaScript how to make a constant."
A variable created with const throws an error if you try to change its value later. This guards against the bug of accidentally overwriting a value, so the basic rule is: use const instead of let whenever you don't plan to change the value. The recommended approach in real projects is: use const by default, and only switch to let once you find you actually need to reassign it.
The sample code declares a constant called MAX_SCORE, displays its value, and then deliberately triggers an error by attempting to reassign it with MAX_SCORE = 200. Since this is caught with try...catch, you can see exactly what the error message looks like. Writing a constant's name in uppercase with underscores, like MAX_SCORE, is a naming convention used across many languages to signal "a value that doesn't change."
A common beginner stumbling block is that even with const, the "contents" of an object or array declared with it can still be changed. What const prohibits is only "reassigning the variable itself" — changing an object's property or an array's elements is perfectly allowed. Without understanding this distinction, it's easy to get confused wondering "why did the contents change even though it's const?"
In real development, "use const by default" is a widely established basic rule across many teams, meant to prevent unintended changes. It's such a valued habit that code review sometimes flags a value that should never actually change but was declared with let instead.
Even when an object or array is declared with const, if you want to prevent its contents from being changed too, more strictly, you use Object.freeze(). Combining const and Object.freeze() prevents both reassignment of the variable and changes to its properties.
A variable declared with let can not only be reassigned deliberately, but also accidentally overwritten inside a loop without you noticing. To prevent this kind of accident too, it's a good habit to think in the order "start with const, switch to let only if necessary."
💡 Anything passed to console.log() appears in the output below.
