❗️Что будет на выходе:

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

async function asyncFunc() {
  for (let value of gen()) {
    await new Promise(res => setTimeout(res, 100));
    console.log(value);
  }
  return 'done';
}

const result = asyncFunc();
console.log(result instanceof Promise);

Ответ: true 1 2 3

JavaScript test | #JavaScript & Max

❗️Что будет на выходе:

async function fetchData() {
  return 'Data loaded';
}

async function processData() {
  console.log('Starting...');
  try {
    const result = fetchData();
    console.log(result);
    console.log(await result);
    return 'Processing complete';
  } catch (error) {
    return 'Error occurred';
  } finally {
    console.log('Cleanup');
  }
}

processData().then(result => console.log(result));

Ответ: Starting... Promise { 'Data loaded' } Data loaded Cleanup Processing complete

JavaScript test | #JavaScript & Max

❗️Что будет на выходе:

let x = 5;

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

foo();

Ответ: ReferenceError: Cannot access 'x' before initialization

JavaScript test | #JavaScript & Max

❗️Что будет на выходе:

const obj = {};
Object.defineProperty(obj, 'name', {
  value: 'Alice',
  writable: false,
  configurable: false
});

try {
  obj.name = 'Bob';
  delete obj.name;
  console.log(obj.name);
} catch (e) {
  console.log('Error:', e.message);
}

Ответ: Alice

JavaScript test | #JavaScript & Max

❗️Что будет на выходе:

function analyze(...items) {
  const [first, ...rest] = items;
  const { length } = [...rest, 'bonus'];
  const result = {
    ...first,
    count: length,
  };
  
  console.log(result);
}

analyze({ id: 42, name: 'Item' }, 'a', 'b');

Ответ: { id: 42, name: 'Item', count: 3 }

JavaScript test | #JavaScript & Max

❗️Что будет на выходе?

const privateData = new WeakMap();

function Person(name) {
  privateData.set(this, { name, secretCount: 0 });
  
  this.greet = function() {
    const data = privateData.get(this);
    data.secretCount++;
    return `Hello, my name is ${data.name}`;
  };
  
  this.getSecretCount = function() {
    return privateData.get(this).secretCount;
  };
}

const alice = new Person('Alice');
alice.greet();
alice.greet();

const result = [
  privateData.has(alice),
  alice.name,
  alice.getSecretCount()
];

console.log(result);

Ответ: [true, undefined, 2]

JavaScript test | #JavaScript & Max

❗️Что будет на выходе:

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

async function asyncFunc() {
  for (let value of gen()) {
    await new Promise(res => setTimeout(res, 100));
    console.log(value);
  }
  return 'done';
}

const result = asyncFunc();
console.log(result instanceof Promise);

Ответ: true 1 2 3

JavaScript test | #JavaScript & Max

❗️Что будет на выходе:

"use strict";

function createCounter() {
  let count = 0;

  return {
    increment() { count++; },
    get value() { return count; },
    reset: function() { count = 0; }
  };
}

const counter = createCounter();
counter.increment();
counter.increment();
counter.increment();

const { value, reset } = counter;
reset();

console.log(counter.value, value);

Ответ: 0 3

JavaScript test | #JavaScript & Max

❗️Что будет на выходе:

function recursivePalindromeCheck(str) {
  if (str.length <= 1) {
    return true;
  }

  return str[0] === str[str.length - 1] && recursivePalindromeCheck(str.slice(1, -1));
}

const result = recursivePalindromeCheck("radar");

console.log(result);

Ответ: true

JavaScript test | #JavaScript & Max

❗️Что будет на выходе:

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);
}

Ответ: true 'TypeError' true

JavaScript test | #JavaScript & Max

❗️Что будет на выходе:

const target = { a: 1, b: 2 };
const handler = {
  get(obj, prop) {
    return prop in obj ? obj[prop] * 2 : 'Not found';
  }
};

const proxy = new Proxy(target, handler);

// Add property to original object
target.c = 3;

// Modify existing property directly on proxy
proxy.a = 10;

// Use Reflect.get instead of direct property access
const result = Reflect.get(proxy, 'd', { custom: true });

console.log(proxy.a, proxy.b, proxy.c, result);

Ответ: 20 4 6 Not found

JavaScript test | #JavaScript & Max

❗️Что будет на выходе:

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}`);

Ответ:
Eagles-Smith-Williams-Brown-10-0

JavaScript test | #JavaScript & Max

❗️Что будет на выходе:

const str = "  Hello, World!  ";

const result = str
  .trim()
  .split(", ")
  .map((word, i) => {
    return i === 0
      ? word.toUpperCase()
      : word.replace(/!$/, "").split("").reverse().join("") + "?";
  })
  .join(" | ");

const [first, ...rest] = result.split(" | ");
const final = `${first} | ${rest.join(" & ")}`;

console.log(final);

Ответ:
HELLO | dlroW?

JavaScript test | #JavaScript & Max

❗️Что будет на выходе:

const p1 = new Promise((resolve) => {
  console.log("A");
  resolve("B");
});

const p2 = p1.then((val) => {
  console.log(val);
  return "C";
});

p2.then((val) => {
  console.log(val);
});

console.log("D");

Ответ:
A D B C
JavaScript test | #JavaScript & Max

❗️Что будет на выходе:

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

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

Ответ: 5 20 30 20

JavaScript test | #JavaScript & Max

❗️Что будет на выходе:

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);

Ответ: I have been coding in <span>JavaScript</span> for <span>10</span> years


JavaScript test | #JavaScript & Max

❗️Что будет на выходе:

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);

Ответ: [true, 5, true, 'undefined']

JavaScript test | #JavaScript & Max

❗️Что будет на выходе:

function createCounter() {
  let count = 0;
  return {
    increment() {
      count++;
      return count;
    },
    getCount() {
      return count;
    }
  };
}

const counter = createCounter();

console.log(counter.increment());
console.log(counter.getCount());
console.log(counter.increment());
console.log(counter.getCount());

Ответ: 1, 1, 2, 2

JavaScript test | #JavaScript & Max

❗️Что будет на выходе:

const counter = (function () {
  let count = 0;
  const history = [];

  return {
    increment(step = 1) {
      count += step;
      history.push(count);
      return this;
    },
    decrement(step = 1) {
      count -= step;
      history.push(count);
      return this;
    },
    getHistory: () => history,
    getCount: () => count,
  };
})();

counter.increment(5).increment(3).decrement(2);

console.log(counter.getCount(), counter.getHistory().join(" -> "));

Ответ: 6 5 -> 8 -> 6

JavaScript test | #JavaScript & Max

❗️Что будет на выходе:

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));

Ответ: { status: 'Range Error', message: 'Amount must be positive' }

JavaScript test | #JavaScript & Max

❗️Что будет на выходе?

function* counter() {
  let i = 0;
  while (true) {
    const direction = yield i;
    if (direction === 'up') i += 2;
    else if (direction === 'down') i -= 1;
    else i += 1;
  }
}

const count = counter();
console.log(count.next().value);
console.log(count.next('up').value);
console.log(count.next('down').value);
console.log(count.next().value);

Ответ: 0 2 1 2

JavaScript test | #JavaScript & Max