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

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

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

const createMathOps = (base) => {
  return {
    add: (x) => base + x,
    multiply: (x) => base * x
  };
};

const createAdvancedMathOps = (base) => {
  const basicOps = createMathOps(base);
  return {
    ...basicOps,
    square: () => basicOps.multiply(base),
    addThenSquare: (x) => {
      const added = basicOps.add(x);
      return added * added;
    }
  };
};

const calculator = createAdvancedMathOps(5);
console.log(calculator.addThenSquare(3));

Ответ: 64

JavaScript test | #JavaScript & Max

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

const partial = (fn, ...presetArgs) => {
  return function partiallyApplied(...laterArgs) {
    return fn(...presetArgs, ...laterArgs);
  };
};

const calculateTax = (taxRate, discount, price) => {
  const discounted = price - (price * discount) / 100;
  return parseFloat((discounted + (discounted * taxRate) / 100).toFixed(2));
};

const withVAT = partial(calculateTax, 20);
const withVATandDiscount = partial(withVAT, 15);

console.log(withVAT(0, 100));
console.log(withVATandDiscount(200));
console.log(partial(calculateTax, 10, 5)(50));

Ответ: 120 204 52.25

JavaScript test | #JavaScript & Max

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

function processConfig(config) {
  const settings = {
    timeout: config.timeout ?? 1000,
    retries: config.retries ?? 3,
    logging: config.logging ?? false,
    debug: config.debug || true
  };
  
  return settings;
}

const userConfig = {
  timeout: 0,
  retries: null,
  logging: false,
  debug: false
};

console.log(processConfig(userConfig));

Ответ: { timeout: 0, retries: 3, logging: false, debug: true }

JavaScript test | #JavaScript & Max

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

const user = {
  profile: {
    name: 'Alice',
    social: null,
    getDetails() {
      return { verified: true };
    }
  }
};

const result = [
  user?.profile?.name,
  user?.profile?.social?.handle,
  user.profile.getDetails?.()?.verified,
  user?.nonExistent?.property
];

console.log(result);

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

JavaScript test | #JavaScript & Max