JavaScript test

const weakMap = new WeakMap();
const obj1 = {};
const obj2 = { key: 'value' };

weakMap.set(obj1, obj2);

const result = weakMap.get(obj1).key.split('').reverse().join('');

console.log(result);

class EventEmitter {
  constructor() {
    this.events = {};
  }
  
  on(event, callback) {
    this.events[event] = this.events[event] || [];
    this.events[event].push(callback);
    return this;
  }
  
  emit(event, data) {
    if (this.events[event]) {
      this.events[event].forEach(cb => cb(data));
    }
    return this;
  }
}

const emitter = new EventEmitter();
emitter.on('test', x => console.log(x * 2))
       .on('test', x => console.log(x + 5))
       .emit('test', 10);

let a = 1;
let b = new Number(1);
let c = '1';

console.log(a == b);
console.log(a === b);
console.log(b == c);

function highlight(strings, ...values) {
  return strings.reduce((result, str, i) => {
    const value = values[i] ? `<span>${values[i]}</span>` : '';
    return result + str + value;
  }, '');
}

const language = 'JavaScript';
const years = 10;

const result = highlight`I have been coding in ${language} for ${years} years`;
console.log(result);

function mystery() {
  try {
    throw new Error('Oops');
    return 'A';
  } catch (err) {
    return 'B';
  } finally {
    return 'C';
  }
}

function wrapper() {
  try {
    return mystery();
  } finally {
    console.log('D');
  }
}

console.log(wrapper());

function X() {}
X.prototype.getValue = function() {
  return this.value;
};

function Y() {
  this.value = 42;
}
Y.prototype = Object.create(X.prototype);
Y.prototype.constructor = Y;

var y = new Y();
console.log(y.getValue());

try {
  try {
    // Creating a custom error type
    class CustomError extends Error {
      constructor(message) {
        super(message);
        this.name = "CustomError";
      }
    }
    
    const fn = () => {
      throw new CustomError("Something went wrong");
    };
    
    try {
      fn();
    } catch (e) {
      throw new TypeError("Type error occurred");
    }
  } catch (e) {
    console.log(e instanceof Error, e.name, e instanceof TypeError);
  }
} catch (e) {
  console.log("Outer catch", e.message);
}

class Logger {
  log(msg) {
    return `[LOG]: ${msg}`;
  }
}

class Formatter {
  format(text) {
    return text.toUpperCase();
  }
}

class Service {
  constructor(logger, formatter) {
    this.logger = logger;
    this.formatter = formatter;
  }
  
  process(data) {
    const formatted = this.formatter.format(data);
    return this.logger.log(formatted);
  }
}

const service = new Service(new Logger(), new Formatter());
console.log(service.process('hello world'));

var arr=[1,2,3,4,5];
console.log(arr.map((prev,curr)=>prev+curr));
console.log(arr.reduce((a,b)=>a+b));
console.log(arr.filter((a,b)=> (a + b) <= 5));

const data = '{"users": [{"name": "Sarah", "age": 25}, {"name": "Mike", "age": null}]}';

try {
  const parsed = JSON.parse(data);
  const result = parsed.users.map(user => {
    return user.age ?? 'unknown';
  });
  console.log(result.join(' - '));
} catch (error) {
  console.log('Parse error occurred');
}

const invalidJson = '{"name": "John", age: 30}';
try {
  JSON.parse(invalidJson);
  console.log('Success');
} catch {
  console.log('Invalid');
}

const user = {
  name: 'Sarah',
  age: 25,
  getName() { return this.name; },
  getAge: () => this.age
};

const methods = {
  regular: user.getName,
  arrow: user.getAge
};

console.log(methods.regular());
console.log(methods.arrow());
console.log(user.getName());
console.log(user.getAge());

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

const result = numbers
  .map(n => n * 2)
  .filter(n => n > 5)
  .reduce((acc, n, index) => {
    acc.sum += n;
    acc.indices.push(index);
    return acc;
  }, { sum: 0, indices: [] });

console.log(result.sum);
console.log(result.indices);

async function asyncFunc() {
  console.log('Async Start');
  await new Promise(resolve => setTimeout(resolve, 100));
  console.log('Async End');
}

console.log('Script Start');
asyncFunc();
setTimeout(() => console.log('Timeout 1'), 50);
setTimeout(() => console.log('Timeout 2'), 150);
console.log('Script End');

class SimpleObservable {
  constructor(subscribeFn) {
    this.subscribeFn = subscribeFn;
  }
  
  subscribe(observer) {
    return this.subscribeFn(observer);
  }
}

const obs = new SimpleObservable(observer => {
  observer.next('first');
  observer.next('second');
  observer.complete();
});

const results = [];
obs.subscribe({
  next: val => results.push(val),
  complete: () => results.push('done')
});

console.log(results.join('-'));

var str="My name is John";
var words1=str.split(" ",3);
console.log("words1:",words1);
var words2=str.split(" ",5);
console.log("words2:",words2);

const original = {
  name: 'Sarah',
  hobbies: ['reading', 'coding'],
  address: { city: 'Portland', zip: 97201 }
};

const shallow = { ...original };
const deep = JSON.parse(JSON.stringify(original));

shallow.name = 'Emma';
shallow.hobbies.push('hiking');
shallow.address.city = 'Seattle';

deep.hobbies.push('swimming');
deep.address.zip = 98101;

console.log(original.hobbies.length, original.address.city);

const user = {
  profile: {
    settings: {
      theme: 'dark',
      notifications: null
    }
  }
};

const result1 = user?.profile?.settings?.theme;
const result2 = user?.profile?.settings?.notifications?.email;
const result3 = user?.profile?.preferences?.language ?? 'en';
const result4 = user?.profile?.settings?.notifications?.push?.('test');

console.log(result1, result2, result3, result4);

function createCounter() {
  let count = 0;
  
  return {
    increment() {
      return ++count;
    },
    reset() {
      const oldCount = count;
      count = 0;
      return oldCount;
    }
  };
}

const counterA = createCounter();
const counterB = createCounter();

counterA.increment();
counterA.increment();
counterB.increment();
const result = counterA.reset() + counterB.reset();
console.log(result);

const array = [1, 2, 3, 4];
const result = array.reduceRight((acc, val) => acc - val);

console.log(result);