How to fix Value of type 'string | undefined' is not iterable in TypeScript

// ❌ Error: Value of type 'string[] | undefined' is not iterable
function processItems(items: string[] | undefined) {
  for (const item of items) {  // Error!
    console.log(item);
  }
}

// ✅ Fix: Check for undefined first
function processItems(items: string[] | undefined) {
  if (!items) return;

  for (const item of items) {  // Safe now
    console.log(item);
  }
}

// ✅ Alternative: Use optional chaining with forEach
function processItems(items: string[] | undefined) {
  items?.forEach(item => console.log(item));
}

// ❌ Error: Type '{ name: string; age: number; }' is not iterable
const user = { name: 'Alice', age: 30 };
for (const prop of user) {  // Error!
  console.log(prop);
}

// ✅ Fix: Use Object.entries() for key-value pairs
for (const [key, value] of Object.entries(user)) {
  console.log(key, value);
}

// ✅ Or use Object.keys() for just keys
for (const key of Object.keys(user)) {
  console.log(key, user[key as keyof typeof user]);
}

// ✅ Or use Object.values() for just values
for (const value of Object.values(user)) {
  console.log(value);
}

// ❌ Error: Incorrectly typed as object
function sumNumbers(nums: object) {
  let sum = 0;
  for (const num of nums) {  // Error: object is not iterable
    sum += num;
  }
  return sum;
}

// ✅ Fix: Type as array
function sumNumbers(nums: number[]) {
  let sum = 0;
  for (const num of nums) {
    sum += num;
  }
  return sum;
}

// ✅ Or use generic iterable interface
function sumNumbers(nums: Iterable<number>) {
  let sum = 0;
  for (const num of nums) {
    sum += num;
  }
  return sum;
}

// ❌ Error with Map or Set values
const userMap = new Map([['id1', 'Alice'], ['id2', 'Bob']]);
// Can't spread the map directly in some contexts

// ✅ Convert to array first
const entries = Array.from(userMap);
const ids = [...userMap.keys()];
const names = [...userMap.values()];

// ❌ Single value mistaken for iterable
const value: string | string[] = getSomeValue();
for (const char of value) {  // Error if value is string[]
  // ...
}

// ✅ Ensure it's always an array
const values = Array.isArray(value) ? value : [value];
for (const item of values) {
  // ...
}

class NumberRange {
  constructor(private start: number, private end: number) {}

  // Implement Symbol.iterator
  *[Symbol.iterator]() {
    for (let i = this.start; i <= this.end; i++) {
      yield i;
    }
  }
}

// ✅ Now iterable
const range = new NumberRange(1, 5);
for (const num of range) {
  console.log(num);  // 1, 2, 3, 4, 5
}

const numbers = [...range];  // [1, 2, 3, 4, 5]

// Only use when you're absolutely certain the runtime value is iterable
const items = unknownValue as Iterable<string>;
for (const item of items) {
  console.log(item);
}

// Better: Combine with runtime check
if (typeof (unknownValue as any)[Symbol.iterator] === 'function') {
  const items = unknownValue as Iterable<string>;
  for (const item of items) {
    console.log(item);
  }
}