JavaScript is a programming language that adds interactivity to websites, running in browsers to manipulate HTML and CSS. As of August 2025, it’s a cornerstone of Web3 development.

// Simple JavaScript statement
console.log("Hello, World!");

Practice logging a message:

console.log("Your Name");

Variables store data values. JavaScript supports multiple data types, updated with modern features in 2025 standards.

let name = "John"; // String
const age = 30; // Number
let isStudent = true; // Boolean
let hobbies = ["coding"]; // Array
let person = {name: "John"}; // Object

Practice declaring a variable:

let greeting = "Hello, JS!";
console.log(greeting);

JavaScript supports various operators, with enhanced performance in 2025 ECMAScript updates.

let sum = 10 + 5;
let isEqual = 10 === 10;
let isAdult = age > 18 && true;

Practice an operator:

let x = 5;
console.log(x * 2);

Control execution with conditionals, a key skill for Web3 logic in 2025.

if (age >= 18) {
    console.log("Adult");
} else {
    console.log("Minor");
}

Practice a conditional:

let score = 90;
if (score >= 80) {
    console.log("Pass");
}

Switch statements handle multiple conditions efficiently.

let day = "Monday";
switch (day) {
    case "Monday":
        console.log("Work week start");
        break;
    default:
        console.log("Other day");
}

Practice a switch:

let grade = "A";
switch (grade) {
    case "A":
        console.log("Great!");
        break;
}

Loops execute code repeatedly, optimized for Web3 tasks in 2025.

for (let i = 0; i < 3; i++) {
    console.log(i);
}
let j = 0;
while (j < 3) {
    console.log(j);
    j++;
}

Practice a loop:

for (let i = 0; i < 2; i++) {
    console.log("Loop");
}

Functions are reusable code blocks, essential for Web3 smart contracts in 2025.

function greet(name) {
    return `Hello, ${name}!`;
}
const greetArrow = name => `Hello, ${name}!`;

Practice a function:

function sayHi() {
    console.log("Hi!");
}
sayHi();

Functions can take parameters and return values, critical for Web3 APIs.

function add(a, b = 0) {
    return a + b;
}
console.log(add(5));

Practice a default parameter:

function welcome(name = "Guest") {
    console.log(`Hi, ${name}!`);
}
welcome();

Scope controls variable access; closures are vital for secure Web3 state management.

function outer() {
    let x = 10;
    return function() {
        console.log(x);
    };
}
const inner = outer();
inner();

Practice a closure:

function counter() {
    let count = 0;
    return () => count++;
}
const inc = counter();
console.log(inc());

Arrays are ordered collections, optimized for Web3 data handling in 2025.

let arr = [1, 2];
arr.push(3);
let doubled = arr.map(x => x * 2);

Practice an array method:

let nums = [1, 2];
let evens = nums.filter(x => x % 2 === 0);
console.log(evens);

Objects store key-value pairs, key for Web3 data structures.

let person = {
    name: "Alice",
    age: 25
};
person.job = "Dev";
console.log(person.name);

Practice object manipulation:

let obj = {key: "value"};
console.log(obj.key);

Destructuring and spread simplify data handling, enhanced in 2025 ES updates.

let [a, b] = [1, 2];
let obj = {x: 1};
let newObj = { ...obj, y: 2 };

Practice destructuring:

let {x} = {x: 5};
console.log(x);

The DOM allows JavaScript to interact with HTML, crucial for Web3 UIs in 2025.

const elem = document.querySelector(".class");
const elems = document.querySelectorAll("div");

Practice selecting:

const div = document.querySelector("div");
console.log(div);

Modify DOM elements’ content and styles for dynamic Web3 interfaces.

const elem = document.querySelector("div");
elem.textContent = "New text";
elem.style.color = "blue";

Practice modifying:

const p = document.querySelector("p");
p.textContent = "Updated";

Handle user interactions with events, key for Web3 interactivity.

const btn = document.querySelector("button");
btn.addEventListener("click", () => {
    console.log("Clicked");
});

Practice an event:

const btn = document.querySelector("button");
btn.addEventListener("click", () => console.log("Click"));

Callbacks handle async operations, vital for Web3 API calls in 2025.

function fetchData(cb) {
    setTimeout(() => cb("Data"), 1000);
}
fetchData(data => console.log(data));

Practice a callback:

function process(cb) {
    cb("Done");
}
process(result => console.log(result));

Promises simplify async handling, updated with 2025 Web3 optimizations.

const promise = new Promise((resolve) => {
    setTimeout(() => resolve("Data"), 1000);
});
promise.then(data => console.log(data));

Practice a Promise:

const p = new Promise((resolve) => resolve("OK"));
p.then(res => console.log(res));

Async/await makes async code readable, optimized for 2025 Web3.

async function getData() {
    const data = await new Promise(r => r("Data"));
    console.log(data);
}
getData();

Practice async/await:

async function fetch() {
    const res = await new Promise(r => r("Done"));
    console.log(res);
}
fetch();

let and const improve variable scoping, updated in 2025 ES standards.

let x = 1;
const y = 2;
if (true) {
    let x = 3; // Separate scope
}

Practice const:

const MAX = 100;
console.log(MAX);

Template literals simplify string creation, enhanced for Web3 in 2025.

let name = "Bob";
let greeting = `Hi, ${name}!`;

Practice a template literal:

let user = "Alice";
console.log(`Hello, ${user}!`);

ES6 modules organize code, critical for Web3 modularity in 2025.

export const add = (a, b) => a + b;
import { add } from './math.js';

Practice an export:

export const say = () => "Hi";

Handle errors with try/catch, essential for robust Web3 apps in 2025.

try {
    throw new Error("Fail");
} catch (e) {
    console.error(e.message);
}

Practice try/catch:

try {
    let x = undefined.prop;
} catch (e) {
    console.log("Error");
}

Create custom error types for specific Web3 scenarios:

class CustomError extends Error {
    constructor(msg) {
        super(msg);
        this.name = "CustomError";
    }
}
throw new CustomError("Fail");

Practice a custom error:

class MyError extends Error {
    constructor(msg) {
        super(msg);
    }
}
throw new MyError("Test");

Effective error handling strategies for Web3 reliability:

function validate(data) {
    if (!data) throw new Error("Invalid");
}

Practice an error pattern:

try {
    validate(null);
} catch (e) {
    console.log("Caught");
}

Pure functions have no side effects, ideal for Web3 immutability:

function add(a, b) {
    return a + b;
}

Practice a pure function:

function multiply(x, y) {
    return x * y;
}
console.log(multiply(2, 3));

Higher-order functions take/return functions, key for Web3 abstractions:

function times(n) {
    return x => x * n;
}
const double = times(2);

Practice a higher-order function:

function addBy(n) {
    return x => x + n;
}
const add3 = addBy(3);
console.log(add3(5));

Immutability avoids modifying data in place, critical for Web3 security:

const arr = [1, 2];
const newArr = [...arr, 3];

Practice immutability:

const obj = {a: 1};
const newObj = { ...obj, b: 2 };
console.log(newObj);

Classes provide OOP in JavaScript, enhanced for Web3 in 2025:

class Person {
    constructor(name) {
        this.name = name;
    }
}

Practice a class:

class Car {
    constructor(brand) {
        this.brand = brand;
    }
}
const car = new Car("Ford");
console.log(car.brand);

Common design patterns solve recurring issues, updated for Web3 in 2025:

const module = (function() {
    let x = 0;
    return { getX: () => x };
})();

Practice a module pattern:

const mod = (function() {
    let val = 1;
    return { get: () => val };
})();
console.log(mod.get());

Optimize JavaScript performance, critical for Web3 scalability in 2025:

function debounce(fn, delay) {
    let id;
    return () => {
        clearTimeout(id);
        id = setTimeout(fn, delay);
    };
}

Practice debouncing:

function log() { console.log("Log"); }
const debounced = debounce(log, 1000);
debounced();

Plan before coding, a must for Web3 projects in 2025:

• Define purpose and goals
• Sketch wireframes or layouts
• Prepare assets (images, text)

Practice planning:

// Plan object example
const plan = {
    goal: "To-do App",
    features: ["Add task", "Delete task"]
};
console.log(plan.goal);

Create a simple To-Do App, a practical Web3 project:

let tasks = [];
const addTask = (task) => tasks.push(task);
addTask("Learn JS");
console.log(tasks);

Practice adding a task:

let todos = [];
const addTodo = (todo) => todos.push(todo);
addTodo("Study");
console.log(todos);

Use tools to debug and test, ensuring Web3 reliability:

• Browser DevTools for debugging
• Jest or Mocha for unit testing
• Cross-browser testing

Practice debugging:

try {
    let x = undefined.prop;
} catch (e) {
    console.log(e);
}