JavaScript Syntax and Fundamentals

// Expression statements
x = 5;
y = x + 10;

// Block statement with local scope
{
    let blockScoped = 'local';
    const PI = 3.14159;
}

// Labeled statement for loop control
outer: for (let i = 0; i < 3; i++) {
    for (let j = 0; j < 3; j++) {
        if (i === 1 && j === 1) break outer;
    }
}

// var: function-scoped, hoisted
console.log(x); // undefined (hoisted)
var x = 5;
if (true) {
    var x = 10; // Same variable
}
console.log(x); // 10

// let: block-scoped, TDZ
// console.log(y); // ReferenceError: Cannot access before initialization
let y = 5;
if (true) {
    let y = 10; // Different variable
    console.log(y); // 10
}
console.log(y); // 5

// const: block-scoped, immutable binding
const z = 5;
// z = 10; // TypeError: Assignment to constant
const obj = { a: 1 };
obj.a = 2; // ✓ OK: mutation allowed
// obj = {}; // ✗ TypeError: reassignment not allowed

// Constants
const MAX_RETRY_COUNT = 3;
const API_BASE_URL = 'https://api.example.com';

// Variables and functions (camelCase)
let userName = 'John';
function calculateTotal(items) {
    return items.reduce((sum, item) => sum + item.price, 0);
}

// Classes (PascalCase)
class UserProfile {
    #privateData; // True private field
    
    constructor(name) {
        this._internalId = Math.random(); // Convention-based private
        this.#privateData = name;
    }
}

// Boolean variables (descriptive prefix)
const isActive = true;
const hasPermission = false;
const canEdit = user.role === 'admin';

/**
 * Calculates the total price with tax
 * @param {number} price - Base price of item
 * @param {number} taxRate - Tax rate as decimal (e.g., 0.08)
 * @returns {number} Total price including tax
 * @throws {TypeError} If parameters are not numbers
 * @example
 * calculateTotal(100, 0.08); // Returns 108
 */
function calculateTotal(price, taxRate) {
    if (typeof price !== 'number' || typeof taxRate !== 'number') {
        throw new TypeError('Parameters must be numbers');
    }
    return price * (1 + taxRate);
}

/**
 * @typedef {Object} User
 * @property {string} name - User's full name
 * @property {number} age - User's age
 * @property {string[]} roles - User roles
 */

/** @type {User} */
const user = {
    name: 'John Doe',
    age: 30,
    roles: ['admin', 'user']
};

'use strict';

// 1. Prevents implicit globals
// mistypedVariable = 17; // ReferenceError (without strict: creates global)

// 2. Prevents duplicate parameters
// function sum(a, a, c) { } // SyntaxError (without strict: allowed)

// 3. Makes 'this' undefined in functions
function showThis() {
    console.log(this); // undefined (without strict: window/global)
}
showThis();

// 4. Prevents assignment to non-writable properties
const obj = {};
Object.defineProperty(obj, 'x', { value: 42, writable: false });
// obj.x = 9; // TypeError (without strict: silently fails)

// 5. Prevents deleting variables
let x = 10;
// delete x; // SyntaxError (without strict: returns false)

// 6. Safer eval
eval('var y = 2;');
// console.log(y); // ReferenceError (without strict: y accessible)

// 7. Octal literals banned
// const octal = 0123; // SyntaxError
const octalCorrect = 0o123; // ✓ Use 0o prefix