JavaScript test

const str = "a 1 b 2 c 3 d 04";

function foo(str) {
   const regex = /\d+/g;
   const matches = str.match(regex);
   return matches.lenght;
}

const fruits = ['apple', 'banana', 'cherry'];
const newFruits = [...fruits];

newFruits.push('date');

const user = { name: 'Taylor', age: 30 };
const updatedUser = { ...user, age: 31 };

user.city = 'Seattle';

console.log(fruits.length, newFruits.length, user.city, updatedUser.city);

const numbers = [0,0,0];

let i = 0;
const result = numbers.reduce((acc, _) => {
  return ++acc;
}, i);

console.log(i, result);

let x = 5;

function foo() {
  console.log(x);
  let x = 10;
  console.log(x);
}

foo();

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

let x = 5;
function addFive(num) {
   return num + 5;
}
x = (x++, x = addFive(x), x *= 2, x -= 5, x += 10);
console.log(x);

const teams = [
  { name: 'Warriors', players: ['Curry', 'Thompson'] },
  { name: 'Lakers', players: ['James', 'Davis'] }
];

const newTeams = JSON.parse(JSON.stringify(teams));
newTeams[0].players.push('Green');

const shallowCopy = [...teams];
shallowCopy[1].name = 'Clippers';

const freezeTest = Object.freeze({nested: {value: 42}});
freezeTest.nested.value = 100;

console.log(teams[1].name, teams[0].players.length, freezeTest.nested.value);

const weakMap = new WeakMap();
const obj = {};

(function() {
  const internalObj = {};
  weakMap.set(internalObj, 'hidden');
  obj.ref = internalObj;
})();

delete obj.ref;

const result = weakMap.has(obj.ref);

console.log(result);

const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

const result = numbers
  .filter(n => n % 2 === 0)
  .map(n => n * 2)
  .reduce((acc, curr, idx, arr) => {
    if (idx === arr.length - 1) {
      return (acc + curr) / arr.length;
    }
    return acc + curr;
  }, 0);

console.log(result);

const array = [1, 2, 3];
array[-1] = 0;

console.log(array.length);

const items = ['apple', 'banana', 'cherry', 'date'];  

const result = items
  .map(item => item.toUpperCase())
  .filter(item => item.length > 5)
  .reduce((acc, item, index) => {
    return acc + (index === 0 ? '' : '-') + item.slice(0, 3);
  }, '');

console.log(result);

const target = {
  secret: "hidden",
  reveal: "nothing"
};

const handler = {
  get: function(obj, prop, receiver) {
    if (prop === "secret") {
      return "revealed";
    }
    return Reflect.get(...arguments);
  }
};

const proxy = new Proxy(target, handler);

with (proxy) {
  console.log(secret);
  console.log(reveal);
}

function processData({ a = 10, b = 20 } = { a: 30 }) {
  console.log(a, b);
}

processData({ a: 5 });
processData();

const cache = new WeakMap();

const user1 = { name: 'Alice' };
const user2 = { name: 'Bob' };

cache.set(user1, { lastLogin: 'yesterday' });
cache.set(user2, { lastLogin: 'today' });

const result = [];
result.push(cache.has(user1));
result.push(cache.get(user2).lastLogin);

let user3 = { name: 'Charlie' };
cache.set(user3, { lastLogin: 'now' });
result.push(cache.has(user3));

user3 = null; // Removing the reference
// Garbage collector might run here in real situations

const user4 = { name: 'Charlie' }; // Same name, different object
result.push(cache.has(user4));

console.log(result);

const obj = {
   x: 10,
   foo() {
      setTimeout(function() {
         console.log(this.x);
      }, 1000);
   }
};
obj.foo();

const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

const result = numbers
  .filter(num => num % 2 === 0)
  .map(num => num * 2)
  .reduce((acc, curr, idx, arr) => {
    if (idx === arr.length - 1) {
      return (acc + curr) / arr.length;
    }
    return acc + curr;
  }, 0);

console.log(result);

function outer() {
  console.log(typeof inner);
  console.log(typeof inner2);
  
  var inner = function() {
    return 'Inside inner';
  };
  
  function inner2() {
    return 'Inside inner2';
  }
  
  console.log(typeof inner);
  console.log(typeof inner2);
}

outer();

function* alternatingGenerator() {
  yield 1;
  yield 2;
  yield 3;
}

const gen = alternatingGenerator();
const result = [gen.next().value, gen.next().value, gen.next().value].reduce((acc, curr) => acc + curr, 0);

console.log(result);

const obj = Object.freeze({
  a: [1, 2, 3],
  b: {
    c: 4
  }
});

obj.a.push(4);
obj.b.c = 5;

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

function* counter() {
  let count = 1;
  while (true) {
    const reset = yield count++;
    if (reset) {
      count = 1;
    }
  }
}

const gen = counter();
console.log(gen.next().value);
console.log(gen.next().value);
console.log(gen.next(true).value);
console.log(gen.next().value);