JavaScript

function modify(obj) {
  obj.a.push(4);
  obj.b = 'changed';
  return obj;
}

const original = { a: [1, 2, 3], b: 'original', c: { deep: true } };
const copy1 = { ...original };
const copy2 = JSON.parse(JSON.stringify(original));

modify(copy1);
console.log(original.a, original.b, copy2.c === original.c);

function processTransaction(amount) {
  try {
    if (typeof amount !== 'number') {
      throw new TypeError('Amount must be a number');
    }
    if (amount <= 0) {
      throw new RangeError('Amount must be positive');
    }
    return 'Transaction processed';
  } catch (error) {
    if (error instanceof TypeError) {
      return { status: 'Type Error', message: error.message };
    } else if (error instanceof RangeError) {
      return { status: 'Range Error', message: error.message };
    }
    return { status: 'Unknown Error', message: error.message };
  }
}

console.log(processTransaction(-50));

const user = { name: 'Alice' };
const ratings = new WeakMap();

ratings.set(user, 5);
const result = [];

result.push(ratings.has(user));
result.push(ratings.get(user));

// Create a reference-free object
let tempUser = { name: 'Bob' };
ratings.set(tempUser, 10);
result.push(ratings.has(tempUser));

// Remove the reference
tempUser = null;

// Try to iterate through WeakMap
result.push(typeof ratings[Symbol.iterator]);

console.log(result);

console.log(1);

setTimeout(() => {
  console.log(2);
  Promise.resolve().then(() => console.log(3));
}, 0);

Promise.resolve()
  .then(() => {
    console.log(4);
    setTimeout(() => console.log(5), 0);
  })
  .then(() => console.log(6));

console.log(7);

const weakSet = new WeakSet();

let obj1 = { id: 1 };
let obj2 = { id: 2 };
let obj3 = obj1;

weakSet.add(obj1);
weakSet.add(obj2);

const results = [
  weakSet.has(obj1),
  weakSet.has(obj3),
  weakSet.has({ id: 2 }),
  weakSet.has(obj2)
];

obj1 = null;

console.log(results);

const user = {
  name: "Alice",
  age: 32,
  role: "developer"
};

const handler = {
  get(target, prop) {
    return prop in target ? 
      `Value: ${target[prop]}` : 
      "Not found";
  }
};

const proxy = new Proxy(user, handler);
delete user.age;

console.log(Reflect.get(proxy, "name") + ", " + proxy.age + ", " + proxy.skills);

const team = {
  name: 'Eagles',
  players: ['Smith', 'Johnson', 'Williams'],
  coach: { name: 'Brown', experience: 12 },
  stats: { wins: 10, losses: 6 }
};

const { 
  name: teamName, 
  players: [firstPlayer, , thirdPlayer],
  coach: { name },
  stats: { wins, draws = 0 }
} = team;

console.log(`${teamName}-${firstPlayer}-${thirdPlayer}-${name}-${wins}-${draws}`);

const a = 9007199254740991n; // MAX_SAFE_INTEGER as BigInt
const b = 2n;
const c = a + b;

const result = [
  a === 9007199254740991,
  a + 1n === 9007199254740992n,
  typeof c,
  c > Number.MAX_SAFE_INTEGER,
  BigInt(9007199254740992) - BigInt(9007199254740991)
];

console.log(result);