JavaScript Fundamentals: Complete Beginner’s Guide with Code Examples (2025)

Key Points:

• JavaScript comes pre-installed in web browsers – no additional installation required
• You can follow along using several different options:
  • Code editors like Sublime Text, Visual Studio Code, or Atom with an HTML file
  • The built-in editor in freeCodeCamp.org’s curriculum
  • CodePen.io where you can write JavaScript in a dedicated panel
  • Scrimba.com, which was used for recording most of this tutorial
• Use console.log() to display output in the browser’s console

My Take:

I recommend beginners start with CodePen or the freeCodeCamp editor since they require zero setup. Once you’re more comfortable, transitioning to VS Code will give you a more professional development environment. The important thing is to start writing code immediately rather than getting stuck in the setup phase.

Comments:

• Single-line comments use // syntax
• Multi-line comments use /* */ syntax
• Comments are intentionally ignored by JavaScript during execution

JavaScript Data Types:

• undefined – something that hasn’t been defined yet
• null – explicitly “nothing”
• boolean – true or false values
• string – text enclosed in quotes
• symbol – immutable primitive value that is unique
• number – numeric values
• object – stores key-value pairs

// This is a single-line comment

/* This is 
   a multi-line
   comment */

// Examples of different data types:
var undefinedValue;           // undefined
var nothingValue = null;      // null
var isTrue = true;            // boolean
var myName = "Beau";          // string
var myNumber = 42;            // number
var myObject = {              // object
  firstName: "Beau",
  lastName: "Carnes"
};
    

Variable Declaration Methods:

• var – the original way to declare variables (function-scoped)
• let – introduced in ES6, block-scoped and allows reassignment
• const – also introduced in ES6, block-scoped but can’t be reassigned

Assignment vs. Declaration:

• Declaration: Creating a variable name (e.g., var a;)
• Assignment: Setting a value to a variable (e.g., a = 7;)
• You can combine declaration and assignment in one line (e.g., var a = 7;)

Uninitialized Variables:

• Variables are undefined when declared but not assigned a value
• Mathematical operations on undefined variables result in NaN (Not a Number)
• Concatenating strings with undefined variables results in a string literal “undefined”

// Variable declaration examples
var a;                    // Declares a variable without assigning a value
var b = 2;                // Declares and assigns in the same line

// Assigning values to already declared variables
a = 7;
b = a;                    // b now equals 7

// Let declaration (ES6)
let ourName = "freeCodeCamp";

// Const declaration (ES6)
const PI = 3.14;          // Convention: use UPPERCASE for constants

// Variable naming is case-sensitive
var StUdLyCapVar;
var studlyCapVar;         // These are different variables

console.log(a);           // Outputs: 7
    

My Take:

For modern JavaScript development, I recommend using const by default, and only switching to let when you know a variable will need to be reassigned. This practice prevents accidental reassignment bugs and makes your code more predictable. Avoid using var in new code, as its function-scoping behavior can lead to unexpected issues.

Basic Operations:

• Addition with +
• Subtraction with -
• Multiplication with *
• Division with /
• Remainder (modulo) with %

Increment and Decrement:

• Increment by 1: myVar++ (same as myVar = myVar + 1)
• Decrement by 1: myVar-- (same as myVar = myVar - 1)

Compound Assignment:

• Addition: myVar += 5 (same as myVar = myVar + 5)
• Subtraction: myVar -= 5 (same as myVar = myVar - 5)
• Multiplication: myVar *= 5 (same as myVar = myVar * 5)
• Division: myVar /= 5 (same as myVar = myVar / 5)

// Basic operations
var sum = 10 + 10;        // sum equals 20
var difference = 45 - 33; // difference equals 12
var product = 8 * 10;     // product equals 80
var quotient = 66 / 33;   // quotient equals 2

// Increment and decrement
var myVar = 87;
myVar++;                  // myVar is now 88
myVar--;                  // myVar is back to 87

// Working with decimals
var myDecimal = 0.009;
var productDecimal = 2.5 * 2.0;  // equals 5.0
var quotientDecimal = 4.4 / 2.0; // equals 2.2

// Finding remainders
var remainder = 11 % 3;   // remainder equals 2

// Compound assignment
var a = 3;
a += 12;                  // a is now 15
a -= 6;                   // a is now 9
a *= 5;                   // a is now 45
a /= 9;                   // a is now 5
    

Creating Strings:

• Use single quotes: 'This is a string'
• Use double quotes: "This is a string"
• Use backticks (ES6): `This is a string`

Escaping Characters:

• Use backslash to escape quotes: ", '
• Other escape sequences: n (newline), t (tab), \ (backslash), etc.

String Operations:

• Concatenation with + operator: "Hello " + "World"
• Compound concatenation with +=: myStr += " World"
• Finding string length: myStr.length

Accessing Characters:

• Zero-based indexing: firstName[0] (first character)
• Last character: firstName[firstName.length - 1]
• Strings are immutable: individual characters can’t be changed

// Declaring strings
var myFirstName = "Beau";
var myLastName = 'Carnes';

// Escaping quotes in strings
var myStr = "I am a "double quoted" string";
var myStr = 'I am a "double quoted" string'; // Alternative approach

// Escape sequences
var myStr = "FirstLinent\SecondLinenThirdLine";

// Concatenating strings
var ourStr = "I come first. " + "I come second.";

// Concatenating with +=
var myStr = "This is the first sentence. ";
myStr += "This is the second sentence.";

// Building strings with variables
var myName = "Beau";
var myStr = "My name is " + myName + " and I am well!";

// Finding string length
var firstNameLength = firstName.length;

// Accessing specific characters
var firstLetter = firstName[0]; // Gets the first letter
var lastLetter = firstName[firstName.length - 1]; // Gets the last letter

// String immutability
var myStr = "Jello World";
myStr[0] = "H"; // This doesn't work! 
myStr = "Hello World"; // This is how you change the string
    

My Take:

For modern JavaScript, I recommend using template literals (backticks) whenever you need to insert variables into strings or create multi-line strings. They’re more readable and less error-prone than concatenation. For example: `Hello, ${userName}!` instead of "Hello, " + userName + "!"

Array Basics:

• Arrays are created with square brackets: [element1, element2, ...]
• Arrays can contain different data types: ["string", 42, true]
• Nested arrays (arrays within arrays) are possible
• Access elements using zero-based indexing: myArray[0]

Array Modification:

• Arrays are mutable: myArray[1] = 45;
• push(): Add elements to the end of an array
• pop(): Remove and return the last element
• shift(): Remove and return the first element
• unshift(): Add elements to the beginning of an array

Multi-dimensional Arrays:

• Access elements in nested arrays using multiple indices: myArray[1][0]
• Useful for representing grids, tables, or hierarchical data

// Creating arrays
var myArray = ["John", 23];

// Nested arrays
var myArray = [["John", 23], ["dog", 3]];

// Accessing array data with indexes
var myArray = [50, 60, 70];
var myData = myArray[0]; // equals 50

// Modifying array data
myArray[1] = 45; // myArray now equals [50, 45, 70]

// Access multi-dimensional arrays
var myArray = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
var myData = myArray[2][1]; // equals 8

// Array methods
var myArray = ["Stimpson", "J", "cat"];
myArray.push(["happy", "joy"]); // Adds at the end: ["Stimpson", "J", "cat", ["happy", "joy"]]

var removedFromMyArray = myArray.pop(); // Removes last element
// myArray is now ["Stimpson", "J", "cat"] and removedFromMyArray equals ["happy", "joy"]

var removedFromMyArray = myArray.shift(); // Removes first element
// myArray is now ["J", "cat"] and removedFromMyArray equals "Stimpson"

myArray.unshift("Paul"); // Adds to beginning: ["Paul", "J", "cat"]

// Shopping list example
var myList = [
  ["cereal", 3],
  ["milk", 2],
  ["bananas", 3],
  ["juice", 2],
  ["eggs", 12]
];
    

My Take:

Arrays are one of the most versatile data structures in JavaScript. Beyond the basic methods covered here, I recommend learning about map(), filter(), reduce(), and forEach() once you’re comfortable with the fundamentals. These higher-order functions will dramatically improve your ability to process and transform array data elegantly.

Function Basics:

• Define with function keyword: function functionName() { ... }
• Call (invoke) by using the function name with parentheses: functionName();
• Functions can accept parameters: function functionName(param1, param2) { ... }
• Functions can return values with the return statement

Scope Concepts:

• Global scope: Variables defined outside any function
• Local scope: Variables defined inside a function
• Local variables take precedence over global variables with the same name
• Variables without var, let, or const become global automatically (not recommended)

Function Return Values:

• Functions without a return statement return undefined
• The return statement immediately exits the function
• You can store function return values in variables: var result = myFunction();

// Basic function
function reusableFunction() {
  console.log("Hi World");
}

reusableFunction(); // Calls the function

// Function with parameters
function functionWithArgs(a, b) {
  console.log(a + b);
}

functionWithArgs(10, 5); // Outputs: 15

// Global vs local scope
var myGlobal = 10; // Global variable

function fun1() {
  // This variable is only available inside this function
  var oopsGlobal = 5; // Local variable
}

function fun2() {
  var output = "";
  if (typeof myGlobal != "undefined") {
    output += "myGlobal: " + myGlobal;
  }
  if (typeof oopsGlobal != "undefined") {
    output += " oopsGlobal: " + oopsGlobal; // This won't run because oopsGlobal is local to fun1
  }
  console.log(output);
}

// Local variables take precedence
var outerWear = "T-Shirt"; // Global variable

function myOutfit() {
  var outerWear = "sweater"; // Local variable takes precedence
  return outerWear;
}

console.log(myOutfit()); // Returns "sweater"
console.log(outerWear); // Still "T-Shirt" globally

// Return values
function timesFive(num) {
  return num * 5;
}

console.log(timesFive(5)); // Outputs: 25

// Assigning returned values
function processArg(num) {
  return (num + 3) / 5;
}

var processed = processArg(7); // processed equals 2
    

My Take:

Functions are the building blocks of JavaScript programming. I recommend getting comfortable with both regular functions and arrow functions (covered later). When naming functions, use verbs that describe what the function does (like calculateTotal or fetchUserData). This creates self-documenting code that’s easier to understand at a glance.

Conditional Statements:

• if statements execute code if a condition is true
• else statements provide an alternative if the condition is false
• else if statements test additional conditions
• switch statements are an alternative to multiple if/else statements

Comparison Operators:

• Equality: == (converts types) and === (strict equality, no type conversion)
• Inequality: != (converts types) and !== (strict inequality)
• Greater/Less than: >, <, >=, <=

Logical Operators:

• AND: && (both conditions must be true)
• OR: || (at least one condition must be true)

// If statements
function trueOrFalse(wasThatTrue) {
  if (wasThatTrue) {
    return "Yes, that was true";
  }
  return "No, that was false";
}

// Equality operator
function testEqual(val) {
  if (val == 12) {
    return "Equal";
  }
  return "Not Equal";
}

// Strict equality operator
function testStrict(val) {
  if (val === 7) {
    return "Equal";
  }
  return "Not Equal";
}

// Inequality operators
function testNotEqual(val) {
  if (val != 99) {
    return "Not Equal";
  }
  return "Equal";
}

// Comparison operators
function testGreaterThan(val) {
  if (val > 100) {
    return "Over 100";
  }
  if (val > 10) {
    return "Over 10";
  }
  return "10 or Under";
}

// Logical AND
function testLogicalAnd(val) {
  if (val <= 50 && val >= 25) {
    return "Yes";
  }
  return "No";
}

// Logical OR
function testLogicalOr(val) {
  if (val < 10 || val > 20) {
    return "Outside";
  }
  return "Inside";
}

// If/Else statements
function testElse(val) {
  if (val > 5) {
    return "Bigger than 5";
  } else {
    return "5 or Smaller";
  }
}

// Else If statements
function testElseIf(val) {
  if (val > 10) {
    return "Greater than 10";
  } else if (val < 5) {
    return "Smaller than 5";
  } else {
    return "Between 5 and 10";
  }
}

// Switch statements
function caseInSwitch(val) {
  switch(val) {
    case 1:
      return "alpha";
      break;
    case 2:
      return "beta";
      break;
    case 3:
      return "gamma";
      break;
    case 4:
      return "delta";
      break;
  }
}

// Default option in Switch
function switchOfStuff(val) {
  switch(val) {
    case "a":
      return "apple";
      break;
    case "b":
      return "bird";
      break;
    case "c":
      return "cat";
      break;
    default:
      return "stuff";
      break;
  }
}

// Multiple identical cases in Switch
function sequentialSizes(val) {
  switch(val) {
    case 1:
    case 2:
    case 3:
      return "Low";
      break;
    case 4:
    case 5:
    case 6:
      return "Mid";
      break;
    case 7:
    case 8:
    case 9:
      return "High";
      break;
  }
}
    

My Take:

When working with conditionals, I always recommend using the strict equality operators (=== and !==) over their non-strict counterparts. The type conversion in non-strict equality can lead to unexpected bugs. Additionally, consider using the ternary operator (covered later) for simple if/else conditions to make your code more concise.

Object Basics:

• Create with curly braces: { key1: value1, key2: value2 }
• Properties can store any data type, including other objects and functions
• Access properties using dot notation: object.property
• Access properties using bracket notation: object["property"]

Working with Objects:

• Add new properties: myDog.bark = "woof";
• Update existing properties: myDog.name = "Happy Coder";
• Delete properties: delete myDog.tails;
• Check if a property exists: myObj.hasOwnProperty("property")

Complex Objects:

• Objects can contain arrays
• Objects can be nested within arrays
• Objects can contain other objects

// Creating objects
var ourDog = {
  "name": "Camper",
  "legs": 4,
  "tails": 1,
  "friends": ["everything!"]
};

// Accessing object properties with dot notation
var hatValue = testObj.hat;      // equals "ballcap"
var shirtValue = testObj.shirt;  // equals "jersey"

// Accessing object properties with bracket notation
var entreeValue = testObj["an entree"];    // equals "hamburger"
var drinkValue = testObj['the drink'];     // equals "water"

// Accessing object properties with variables
var testObj = {
  12: "Namath",
  16: "Montana",
  19: "Unitas"
};
var playerNumber = 16;
var player = testObj[playerNumber];   // equals "Montana"

// Updating object properties
ourDog.name = "Happy Camper";    // Changed from "Camper" to "Happy Camper"

// Adding new properties
ourDog.bark = "bow-wow";         // Adds the bark property

// Deleting properties
delete ourDog.bark;              // Removes the bark property

// Using objects for lookups (like a dictionary)
var lookup = {
  "alpha": "Adams",
  "bravo": "Boston"
};
var result = lookup[val];        // Looks up the value associated with val

// Checking if a property exists
function checkObj(checkProp) {
  if (myObj.hasOwnProperty(checkProp)) {
    return myObj[checkProp];
  } else {
    return "Not Found";
  }
}

// Complex objects
var myMusic = [
  {
    "artist": "Billy Joel",
    "title": "Piano Man",
    "release_year": 1973,
    "formats": [
      "CD",
      "8T",
      "LP"
    ]
  },
  {
    "artist": "Beau Carnes",
    "title": "Cereal Man",
    "release_year": 2003,
    "formats": [
      "YouTube video"
    ]
  }
];

// Accessing nested objects
var myStorage = {
  "car": {
    "inside": {
      "glove box": "maps",
      "passenger seat": "crumbs"
    },
    "outside": {
      "trunk": "jack"
    }
  }
};
var gloveBoxContents = myStorage.car.inside["glove box"]; // equals "maps"

// Accessing nested arrays
var myPlants = [
  {
    type: "flowers",
    list: [
      "rose",
      "tulip",
      "dandelion"
    ]
  },
  {
    type: "trees",
    list: [
      "fir",
      "pine",
      "birch"
    ]
  }
];
var secondTree = myPlants[1].list[1]; // equals "pine"
    

My Take:

Objects are at the heart of JavaScript. Nearly everything in JavaScript is an object under the hood, including arrays and functions. I recommend organizing related data into objects rather than using multiple standalone variables. This reduces global namespace pollution and creates more maintainable code. For larger applications, consider learning about object-oriented programming patterns in JavaScript.

Types of Loops:

• while loops run while a condition is true
• for loops run for a specific number of times
• do...while loops always run at least once, then check the condition

For Loop Structure:

• Initialization: sets up a variable before the loop starts
• Condition: evaluated before each loop iteration
• Final expression: executed at the end of each iteration

Common Loop Patterns:

• Iterating through arrays
• Counting forwards or backwards
• Iterating by different increments (2, 5, etc.)
• Nested loops for working with multi-dimensional arrays

// While loop
var myArray = [];
var i = 0;
while (i < 5) {
  myArray.push(i);
  i++;
}
console.log(myArray); // [0, 1, 2, 3, 4]

// Basic for loop
var myArray = [];
for (var i = 1; i < 6; i++) {
  myArray.push(i);
}
console.log(myArray); // [1, 2, 3, 4, 5]

// Iterating odd numbers with for loop
var myArray = [];
for (var i = 1; i < 10; i += 2) {
  myArray.push(i);
}
console.log(myArray); // [1, 3, 5, 7, 9]

// Counting backwards with for loop
var myArray = [];
for (var i = 9; i > 0; i -= 2) {
  myArray.push(i);
}
console.log(myArray); // [9, 7, 5, 3, 1]

// Iterating through arrays with for loop
var arr = [10, 9, 8, 7, 6];
var total = 0;
for (var i = 0; i < arr.length; i++) {
  total += arr[i];
}
console.log(total); // 40

// Nested for loops
function multiplyAll(arr) {
  var product = 1;
  for (var i = 0; i < arr.length; i++) {
    for (var j = 0; j < arr[i].length; j++) {
      product *= arr[i][j];
    }
  }
  return product;
}
var product = multiplyAll([[1,2],[3,4],[5,6,7]]);
console.log(product); // 5040

// Do...while loop
var myArray = [];
var i = 10;
do {
  myArray.push(i);
  i++;
} while (i < 5);
console.log(i, myArray); // 11, [10]
    

My Take:

While traditional loops are important to understand, modern JavaScript offers more elegant solutions for many common looping tasks. Once you're comfortable with the basics, I recommend exploring array methods like forEach(), map(), and filter(). They're more declarative and often lead to more readable code than traditional for loops when working with arrays.

Random Number Generation:

• Math.random() generates a random decimal between 0 (inclusive) and 1 (exclusive)
• Use Math.floor(Math.random() * n) to get a whole number between 0 and n-1
• Calculate a range with Math.floor(Math.random() * (max - min + 1)) + min

// Generate random decimal
function randomFraction() {
  return Math.random();
}
console.log(randomFraction()); // A random decimal between 0 and 1

// Generate random whole number
function randomWholeNum() {
  return Math.floor(Math.random() * 10); // 0-9
}

// Generate random whole number within a range
function randomRange(myMin, myMax) {
  return Math.floor(Math.random() * (myMax - myMin + 1)) + myMin;
}
console.log(randomRange(5, 15)); // A random number between 5 and 15
    

My Take:

The random number generation techniques taught here are perfect for simple applications. However, for applications requiring more sophisticated randomness (like cryptography or scientific simulations), the standard Math.random() might not be sufficient. For those cases, consider libraries specifically designed for high-quality random number generation.

The parseInt Function:

• Converts a string to an integer: parseInt("56") returns 56
• Returns NaN (Not a Number) if the string can't be converted
• Accepts a radix parameter to specify the base: parseInt("10", 2) interprets "10" as binary

The Ternary (Conditional) Operator:

• Shorthand for if-else statements
• Syntax: condition ? expression-if-true : expression-if-false
• Can be nested for multiple conditions

// Using parseInt
function convertToInteger(str) {
  return parseInt(str);
}
console.log(convertToInteger("56")); // 56

// Using parseInt with a radix
function convertToInteger(str) {
  return parseInt(str, 2); // Parse as binary
}
console.log(convertToInteger("10101")); // 21 (in decimal)

// Basic ternary operator
function checkEqual(a, b) {
  return a === b ? true : false;
}

// Multiple ternary operators
function checkSign(num) {
  return num > 0 ? "positive" : num < 0 ? "negative" : "zero";
}
console.log(checkSign(10)); // "positive"
console.log(checkSign(-12)); // "negative"
console.log(checkSign(0)); // "zero"
    

My Take:

The ternary operator is great for simple conditionals that return different values based on a condition. However, for complex logic with multiple outcomes or side effects, traditional if/else statements are often more readable. Remember, code readability is crucial for maintainability, so choose the approach that makes your code clearer to understand.

Variable Declaration:

• let: Block-scoped variable that can be reassigned
• const: Block-scoped variable that cannot be reassigned
• Both help avoid issues with hoisting and accidental redeclaration

Arrow Functions:

• Shorter syntax for writing functions: () => {}
• Implicit return when no curly braces: x => x * 2
• Particularly useful with functional methods like map and filter

Advanced Features:

• Default parameters for functions
• Rest operator (...) for variable arguments
• Spread operator for arrays and objects
• Destructuring assignment for arrays and objects
• Template literals for flexible string creation
• Class syntax for creating objects
• Getters and setters for controlling property access

// Var vs let differences
let catName = "Quincy";
let catName = "Beau"; // Error: Duplicate declaration

// Preventing object mutation
const MATH_CONSTANTS = {
  PI: 3.14
};
Object.freeze(MATH_CONSTANTS);
// Now MATH_CONSTANTS.PI = 99 will throw an error

// Arrow functions
const magic = () => new Date();

// Arrow functions with parameters
const myConcat = (arr1, arr2) => arr1.concat(arr2);

// Default parameters
const increment = (number, value = 1) => number + value;

// Rest operator
const sum = (...args) => args.reduce((a, b) => a + b, 0);

// Spread operator
const arr1 = ['JAN', 'FEB', 'MAR', 'APR', 'MAY'];
let arr2 = [...arr1]; // Creates a copy of arr1

// Destructuring assignment for objects
const { x, y } = { x: 3, y: 7 }; // x = 3, y = 7

// Destructuring with nested objects
const LOCAL_FORECAST = {
  today: { min: 72, max: 83 },
  tomorrow: { min: 73.3, max: 84.6 }
};
const { tomorrow: { max: maxOfTomorrow }} = LOCAL_FORECAST; // maxOfTomorrow = 84.6

// Destructuring assignment with arrays
let [a, b] = [1, 2]; // a = 1, b = 2
[a, b] = [b, a]; // Swaps values: a = 2, b = 1

// Template literals
const person = {
  name: "Zodiac Hasbro",
  age: 56
};
const greeting = `Hello, my name is ${person.name}!
I am ${person.age} years old.`;

// Concise object literal declarations
const createPerson = (name, age, gender) => ({ name, age, gender });

// Concise function declarations in objects
const bicycle = {
  gear: 2,
  setGear(newGear) {
    this.gear = newGear;
  }
};

// Class syntax
class SpaceShuttle {
  constructor(targetPlanet) {
    this.targetPlanet = targetPlanet;
  }
}
const zeus = new SpaceShuttle('Jupiter');

// Getters and setters
class Thermostat {
  constructor(temp) {
    this._temp = 5/9 * (temp - 32); // Convert to Celsius
  }
  get temperature() {
    return this._temp;
  }
  set temperature(updatedTemp) {
    this._temp = updatedTemp;
  }
}
const thermos = new Thermostat(76);
console.log(thermos.temperature); // 24.44 (Celsius)
    

My Take:

ES6 features have dramatically improved JavaScript development. I recommend using these modern syntax features in all new code you write. In particular, arrow functions, template literals, destructuring, and the class syntax make your code more concise and easier to understand. For older browsers, you can use tools like Babel to transpile your modern JavaScript into compatible code.

Export Types:

• Named exports: export { funcName, varName }
• Default exports: export default function() {}
• Inline exports: export const pi = 3.14

Import Types:

• Named imports: import { funcName, varName } from './module'
• Default imports: import anyName from './module'
• Import all: import * as moduleName from './module'

// Named export (in string_function.js)
export const capitalizeString = str => str.toUpperCase();

// Importing a named export
import { capitalizeString } from "./string_function";
console.log(capitalizeString("hello!")); // "HELLO!"

// Multiple exports
export const foo = "bar";
export const bar = "foo";

// Export at the bottom of the file
const capitalizeString = (string) => {
  return string.charAt(0).toUpperCase() + string.slice(1);
}
export { capitalizeString };

// Import everything
import * as stringFunctions from "./string_functions";
stringFunctions.capitalizeString("hello");

// Default export
export default function subtract(x, y) {
  return x - y;
}

// Import a default export
import subtract from "math_functions";
    

My Take:

The module system is a fundamental part of modern JavaScript development. It allows for better code organization, encapsulation, and reusability. I recommend using named exports for most cases, as they make it clear exactly what you're importing. Save default exports for when a module has a clear primary purpose or main function. When working with larger projects, consider using a bundler like Webpack or Rollup to manage your module dependencies.

Where to Go From Here:

• Complete the JavaScript curriculum on freeCodeCamp.org
• Build a few simple projects like a calculator, to-do list, or quiz app
• Learn about DOM manipulation to interact with web pages
• Explore asynchronous JavaScript (callbacks, promises, async/await)
• Dive into a framework like React, Vue, or Angular when you're ready