Вопросы на JavaScript-собеседовании: 35 вопросов с ответами

typeof 42           // 'number'
typeof 'привет'     // 'string'
typeof true         // 'boolean'
typeof undefined    // 'undefined'
typeof null         // 'object' (баг в языке, не исправляют ради совместимости)
typeof Symbol()     // 'symbol'
typeof 10n          // 'bigint'
typeof {}           // 'object'
typeof []           // 'object' (массив — тоже объект)

0 == false    // true  (0 → false)
'' == false   // true  ('' → false)
null == undefined // true
null === undefined // false

'42' == 42    // true  (строка → число)
'42' === 42   // false

'5' + 3      // '53' (число → строка)
'5' - 3      // 2   (строка → число)
true + 1     // 2   (true → 1)
false + 1    // 1   (false → 0)
'' + 0       // '0'
!'hello'     // false (непустая строка → true → !true)
!0           // true  (0 → false → !false)

let a
console.log(a) // undefined

let b = null
console.log(b) // null

typeof undefined // 'undefined'
typeof null      // 'object'

if (true) {
  var x = 1    // доступна вне блока
  let y = 2    // только внутри блока
  const z = 3  // только внутри блока
}
console.log(x) // 1
console.log(y) // ReferenceError

console.log(a) // undefined (var поднялось)
console.log(b) // ReferenceError (let в TDZ)
var a = 1
let b = 2

function counter() {
  let count = 0
  return () => ++count
}

const inc = counter()
inc() // 1
inc() // 2

const obj = {
  name: 'Анна',
  greet() {
    console.log(this.name)
  }
}

obj.greet()         // 'Анна' — this = obj

const fn = obj.greet
fn()                // undefined — this = window/undefined (strict mode)

const btn = document.querySelector('button')
btn.addEventListener('click', obj.greet) // undefined — this = button

function greet(greeting) {
  console.log(`${greeting}, ${this.name}`)
}

const user = { name: 'Анна' }

greet.call(user, 'Привет')    // 'Привет, Анна'
greet.apply(user, ['Привет']) // 'Привет, Анна'

const bound = greet.bind(user)
bound('Привет')               // 'Привет, Анна'

const obj = {
  name: 'Анна',
  greet: () => console.log(this.name),
  hello() { console.log(this.name) }
}

obj.greet()  // undefined (this = window/undefined)
obj.hello()  // 'Анна'    (this = obj)

const animal = { sound: 'generic' }
const cat = Object.create(animal)
cat.sound // 'generic' — найдено в прототипе

class Animal {
  constructor(name) {
    this.name = name
  }
  speak() {
    console.log(this.name)
  }
}

class Dog extends Animal {
  constructor(name) {
    super(name)
  }
}

// Под капотом:
// Dog.prototype.__proto__ === Animal.prototype

const promise = new Promise((resolve, reject) => {
  setTimeout(() => resolve('готово'), 1000)
})

promise
  .then(result => console.log(result))
  .catch(error => console.error(error))
  .finally(() => console.log('всегда'))

async function fetchUser(id) {
  try {
    const response = await fetch(`/api/users/${id}`)
    const user = await response.json()
    return user
  } catch (error) {
    console.error(error)
  }
}

// Ждёт все. Если хоть один упал — весь результат падает
Promise.all([p1, p2, p3])

// Ждёт все. Возвращает статус каждого (fulfilled/rejected)
Promise.allSettled([p1, p2, p3])

// Возвращает первый завершённый (неважно, успех или ошибка)
Promise.race([p1, p2, p3])

console.log('1')
setTimeout(() => console.log('2'), 0)
Promise.resolve().then(() => console.log('3'))
console.log('4')
// Порядок: 1, 4, 3, 2

const doubled = [1, 2, 3].map(n => n * 2)  // [2, 4, 6]
[1, 2, 3].forEach(n => console.log(n))      // undefined

const sum = [1, 2, 3].reduce((acc, n) => acc + n, 0) // 6

const copy = { ...obj }
const copy = Object.assign({}, obj)

const deep = structuredClone(obj)

const obj = Object.freeze({ a: 1, b: { c: 2 } })
obj.a = 3       // не изменится
obj.b.c = 3     // изменится! (вложенный объект не заморожен)

const { name, age } = { name: 'Анна', age: 25 }
const [first, , third] = [1, 2, 3]

function greet({ name, age = 18 }) {
  console.log(`${name}, ${age}`)
}

// Spread — «разворачивает»
const arr = [1, 2, 3]
const copy = [...arr]
const merged = { ...obj1, ...obj2 }

// Rest — «собирает»
function sum(...numbers) {
  return numbers.reduce((a, b) => a + b, 0)
}

const obj = { a: 1, b: { c: 2 } }
const shallow = { ...obj }
shallow.b.c = 3
obj.b.c // 3 — изменилось!

const deep = structuredClone(obj)
deep.b.c = 4
obj.b.c // 3 — не изменилось

// Map — ключи любого типа
const map = new Map()
map.set({ id: 1 }, 'значение')
map.set('ключ', 42)

// Set — только уникальные значения
const set = new Set([1, 2, 2, 3])
set.size // 3

Array.isArray([1, 2, 3]) // true
Array.isArray({})        // false
typeof []                // 'object' — не поможет

;(function () {
  const private = 'скрыто'
  console.log(private)
})()
// console.log(private) — ReferenceError

function* idGenerator() {
  let id = 1
  while (true) yield id++
}

const gen = idGenerator()
gen.next() // { value: 1, done: false }
gen.next() // { value: 2, done: false }

// Debounce — вызов после паузы (откладывает)
function debounce(fn, ms) {
  let timer
  return (...args) => {
    clearTimeout(timer)
    timer = setTimeout(() => fn(...args), ms)
  }
}

// Throttle — не чаще раза в ms (ограничивает)
function throttle(fn, ms) {
  let last = 0
  return (...args) => {
    const now = Date.now()
    if (now - last >= ms) {
      last = now
      fn(...args)
    }
  }
}

console.log('1')
setTimeout(() => console.log('2'), 0)
Promise.resolve().then(() => console.log('3'))
console.log('4')
// 1, 4, 3, 2

const weakMap = new WeakMap()
let obj = { name: 'test' }
weakMap.set(obj, 'данные')
obj = null // объект будет удалён из WeakMap

const original = [1, 2, 3]
const copy = [...original]
const copy2 = original.slice()
const copy3 = Array.from(original)

typeof NaN       // 'number'
NaN === NaN      // false
Number.isNaN(NaN) // true

const user = { address: { city: 'Moscow' } }

user?.address?.city     // 'Moscow'
user?.phone?.number     // undefined (без ошибки)
user?.getName?.()       // undefined

null ?? 'default'    // 'default'
undefined ?? 'hello' // 'hello'
0 ?? 'default'       // 0
'' ?? 'default'      // ''
false ?? true        // false

const obj = { a: 1, b: { c: [2, 3] }, date: new Date() }
const clone = structuredClone(obj)

clone.b.c.push(4)
obj.b.c // [2, 3] — не изменилось
clone.date instanceof Date // true