Practice Questions — Error Handling and Debugging

function safeJsonParse(str, fallback) {
  try {
    return JSON.parse(str);
  } catch (error) {
    return fallback;
  }
}

console.log(safeJsonParse('{"name":"Aarav"}', {}));
console.log(safeJsonParse('bad', []));
console.log(safeJsonParse(null, { error: true }));

function identifyError(fn) {
  try {
    fn();
    return "No error";
  } catch (error) {
    return error.name;
  }
}

console.log(identifyError(() => null.x));        // TypeError
console.log(identifyError(() => JSON.parse('{')));  // SyntaxError
console.log(identifyError(() => 42));             // No error

class ValidationError extends Error {
  constructor(field, message) {
    super(message);
    this.name = 'ValidationError';
    this.field = field;
  }
}

function validateStudent(data) {
  if (typeof data.name !== 'string' || data.name.length < 2) {
    throw new ValidationError('name', 'Name must be at least 2 characters');
  }
  if (typeof data.age !== 'number' || data.age < 5 || data.age > 25) {
    throw new ValidationError('age', 'Age must be a number between 5 and 25');
  }
  if (!data.email || !data.email.includes('@')) {
    throw new ValidationError('email', 'Email must contain @');
  }
  return true;
}

const tests = [
  { name: 'A', age: 16, email: 'a@b.com' },
  { name: 'Aarav', age: 3, email: 'a@b.com' },
  { name: 'Priya', age: 15, email: 'bad' },
  { name: 'Rohan', age: 16, email: 'r@x.com' }
];

for (const test of tests) {
  try {
    validateStudent(test);
    console.log(test.name + ': Valid');
  } catch (e) {
    if (e instanceof ValidationError) {
      console.log(test.name + ': ' + e.field + ' - ' + e.message);
    }
  }
}

function retry(fn, maxAttempts) {
  let lastError;
  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
    try {
      const result = fn();
      console.log('Attempt ' + attempt + ': success -> ' + result);
      return result;
    } catch (error) {
      lastError = error;
      console.log('Attempt ' + attempt + ': failed - ' + error.message);
    }
  }
  throw lastError;
}

let callCount = 0;
function unreliable() {
  callCount++;
  if (callCount < 3) throw new Error('not ready');
  return 42;
}

try {
  retry(unreliable, 5);
} catch (e) {
  console.log('All attempts failed');
}

function safeAccess(obj, path) {
  try {
    const keys = path.split('.');
    let current = obj;
    for (const key of keys) {
      current = current[key];
    }
    return current;
  } catch (error) {
    return undefined;
  }
}

const data = { a: { b: { c: 42 } } };
console.log(safeAccess(data, 'a.b.c'));   // 42
console.log(safeAccess(data, 'a.b'));     // { c: 42 }
console.log(safeAccess(data, 'a.x.y'));   // undefined
console.log(safeAccess(data, 'z'));        // undefined

function testAll(functions) {
  const result = { successes: 0, errors: {} };

  for (const fn of functions) {
    try {
      fn();
      result.successes++;
    } catch (error) {
      const type = error.name;
      result.errors[type] = (result.errors[type] || 0) + 1;
    }
  }

  return result;
}

const fns = [
  () => 42,
  () => null.x,
  () => JSON.parse('{'),
  () => [].length,
  () => undefined.name,
  () => new Array(-1)
];

console.log(testAll(fns));
// { successes: 2, errors: { TypeError: 2, SyntaxError: 1, RangeError: 1 } }

class DebugLogger {
  constructor() {
    this.messages = [];
    this.timers = {};
  }

  log(msg) {
    this.messages.push({ type: 'log', msg, time: Date.now() });
    console.log(msg);
  }

  warn(msg) {
    this.messages.push({ type: 'warn', msg, time: Date.now() });
    console.warn(msg);
  }

  error(msg) {
    this.messages.push({ type: 'error', msg, time: Date.now() });
    console.error(msg);
  }

  time(label) {
    this.timers[label] = Date.now();
  }

  timeEnd(label) {
    if (this.timers[label]) {
      const duration = Date.now() - this.timers[label];
      this.log(label + ': ' + duration + 'ms');
      delete this.timers[label];
    }
  }

  getLog() {
    return this.messages;
  }
}

const logger = new DebugLogger();
logger.log('App started');
logger.warn('Deprecated function used');
logger.time('process');
for (let i = 0; i < 100000; i++) {}
logger.timeEnd('process');
console.log(logger.getLog());