02-basic-types.ts

// ============================================
// 02. Basic Types
// ============================================

console.log("=== PRIMITIVE TYPES ===\n");

// Primitive Types
let age: number = 25;
let price: number = 19.99;
let hex: number = 0xf00d;
let binary: number = 0b1010;
let octal: number = 0o744;

console.log("Numbers:");
console.log(`  Regular: ${age}, Price: ${price}`);
console.log(`  Hex (0xf00d): ${hex}, Binary (0b1010): ${binary}, Octal (0o744): ${octal}`);

let name: string = "Alice";
let greeting: string = `Hello, ${name}!`;
let message: string = 'Single quotes work too';

console.log("\nStrings:");
console.log(`  Regular: ${name}`);
console.log(`  Template literal: ${greeting}`);
console.log(`  Single quotes: ${message}`);

let isActive: boolean = true;
let isComplete: boolean = false;

console.log("\nBooleans:");
console.log(`  isActive: ${isActive}, isComplete: ${isComplete}`);

// Special Types
console.log("\n=== SPECIAL TYPES ===\n");

let value: any = 42;
console.log(`any type - initial value: ${value} (${typeof value})`);
value = "hello";      // OK
console.log(`any type - changed to: ${value} (${typeof value})`);
value = true;         // OK
console.log(`any type - changed to: ${value} (${typeof value})`);
// value.foo.bar.baz(); // No error (but might crash at runtime!)

let unknownValue: unknown = 42;
console.log(`\nunknown type - value: ${unknownValue} (${typeof unknownValue})`);
// unknownValue.toFixed(); // Error: Object is of type 'unknown'

if (typeof unknownValue === "number") {
  const formatted = unknownValue.toFixed(2); // OK, we've narrowed the type
  console.log(`unknown type - after type guard: ${formatted}`);
}

function logMessage(message: string): void {
  console.log(message);
  // No return statement
}

console.log("\nvoid return type:");
logMessage("This function returns void (nothing)");

function throwError(message: string): never {
  throw new Error(message);
}

function infiniteLoop(): never {
  while (true) {
    // Never returns
  }
}

console.log("never return type: Used for functions that never return");
// throwError("This would throw an error"); // Uncomment to see never in action

// Type Inference
console.log("\n=== TYPE INFERENCE ===\n");

let count = 42; // TypeScript infers: number
let userName = "Alice"; // TypeScript infers: string
let active = true; // TypeScript infers: boolean

console.log("TypeScript automatically infers types:");
console.log(`  count = 42 → TypeScript knows it's a ${typeof count}`);
console.log(`  userName = "Alice" → TypeScript knows it's a ${typeof userName}`);
console.log(`  active = true → TypeScript knows it's a ${typeof active}`);

// Type Annotations
console.log("\n=== TYPE ANNOTATIONS ===\n");

let userAge: number = 25;
let userEmail: string;
userEmail = "alice@example.com";

console.log("Explicit type annotations:");
console.log(`  userAge: ${userAge} (explicitly typed as number)`);
console.log(`  userEmail: ${userEmail} (explicitly typed as string)`);

// Literal Types
console.log("\n=== LITERAL TYPES ===\n");

let direction: "up" | "down" | "left" | "right" = "up";
// direction = "center"; // Error: "center" is not in the union type
let diceRoll: 1 | 2 | 3 | 4 | 5 | 6 = 4;
let isTrue: true = true;
// isTrue = false; // Error: false is not a literal type

console.log("Literal types - specific values:");
console.log(`  direction: "${direction}" (can only be "up" | "down" | "left" | "right")`);
console.log(`  diceRoll: ${diceRoll} (can only be 1, 2, 3, 4, 5, or 6)`);
console.log(`  isTrue: ${isTrue} (can only be true)`);

// Type Aliases
console.log("\n=== TYPE ALIASES ===\n");

type Age = number;
type Name = string;
type ID = string | number;

let userAge2: Age = 25;
let userName2: Name = "Alice";
let userId: ID = "123";

console.log("Type aliases - custom names for types:");
console.log(`  userAge2: ${userAge2} (using Age alias for number)`);
console.log(`  userName2: ${userName2} (using Name alias for string)`);
console.log(`  userId: ${userId} (using ID alias for string | number)`);

console.log("\n=== DEMO COMPLETE ===");

export { age, name, isActive, value, unknownValue, direction, userId };