РЕАЛЬНОЕ СОБЕСЕДОВАНИЕ / Middle FRONTEND разработчик MCN TELECOM - от 120 тыс.

29 августа 2025 г. · 168 мин. чтения

Сегодня мы разберем техническое собеседование на позицию фронтенд-разработчика, где интервьюер глубоко погружается в основы JavaScript, React и смежные технологии, задавая вопросы от базовых методов массивов и объектов до механизмов Virtual DOM и хуков. Кандидат демонстрирует уверенные знания на среднем уровне, с редкими пробелами в нюансах вроде глубокого копирования или мемоизации, но активно участвует в диалоге, получая полезные объяснения от интервьюера. Общая атмосфера собеседования конструктивная и ориентирована на оценку практических навыков для реальной работы в IT-команде.

Вопрос 1. Какие методы массива вы знаете и используете?

Таймкод: 00:00:36

Ответ собеседника: неполный. Итерационные методы вроде map, forEach, reduce для сбора, slice для обрезки.

Правильный ответ:
В Go массивы (arrays) — это фиксированные последовательности элементов одного типа с известной на этапе компиляции длиной, в то время как слайсы (slices) — динамические представления на массивы, которые позволяют гибко работать с данными. Go не предоставляет богатый набор встроенных "методов" для массивов и слайсов, как в языках вроде JavaScript или Python (где есть map, filter, reduce). Вместо этого, основная работа ведется через встроенные функции из пакета builtin, итерацию с помощью циклов for и, при необходимости, кастомные реализации. Это отражает философию Go: простота и эффективность без излишеств.

Ключевые встроенные функции для работы с массивами и слайсами:

len() и cap():
- len(s) возвращает текущую длину слайса (количество элементов).
- cap(s) возвращает емкость — максимальное количество элементов, которое слайс может вместить без перераспределения памяти.
  Это базовые метрики, полезные для проверки границ и оптимизации.
  Пример:
```
package main

import "fmt"

func main() {
    s := []int{1, 2, 3}  // Слайс длиной 3
    fmt.Println(len(s))  // Вывод: 3
    fmt.Println(cap(s))  // Вывод: 3 (емкость равна длине для простого слайса)
}
```
make():
Создает слайс с заданной длиной и/или емкостью. Полезно для инициализации без нулевых значений.
Пример:
```
s := make([]int, 5, 10)  // Слайс длиной 5, емкостью 10
// s = [0, 0, 0, 0, 0] (инициализировано нулями)
```
append():
Добавляет один или несколько элементов в конец слайса. Автоматически расширяет емкость при необходимости (Go удваивает емкость для эффективности). Это основной способ динамического роста коллекций. Важно: append возвращает новый слайс, так как может перераспределять память — всегда присваивайте результат.
Пример:
```
s := []int{1, 2}
s = append(s, 3, 4)  // Теперь s = [1, 2, 3, 4]
// Если не присвоить, оригинальный слайс не изменится
```
copy():
Копирует элементы из одного слайса в другой. Полезно для глубокого копирования, чтобы избежать мутации исходных данных. Возвращает количество скопированных элементов.
Пример:
```
src := []int{1, 2, 3}
dst := make([]int, len(src))
n := copy(dst, src)  // n = 3, dst теперь [1, 2, 3]
fmt.Println(n)       // Вывод: 3
```
Слайсинг (slicing):
Не метод, но операция для извлечения подмножества: s[start:end]. Можно расширять слайс за пределы текущей длины до емкости. Это эффективно, так как слайсы — это дескрипторы (header с указателем на массив, длиной и емкостью).
Пример:
```
s := []int{0, 1, 2, 3, 4}
sub := s[1:3]  // sub = [1, 2]
// Расширение: s[2:5] = [2, 3, 4], если cap(s) >= 5
```

Для итерации и трансформаций (аналог map, filter, reduce) Go полагается на циклы for с range:

for i, v := range s { ... } — итерация по индексу и значению.
Это просто и эффективно, без overhead функционального программирования. Для сложных операций часто пишут свои функции или используют пакеты вроде golang.org/x/exp/slices (в Go 1.21+ добавлены Sort, IsSorted и т.д., но базовые итераторы — ручные).

Пример реализации map-подобной функции:

func mapSlice(s []int, f func(int) int) []int {
    result := make([]int, len(s))
    for i, v := range s {
        result[i] = f(v)
    }
    return result
}

// Использование
nums := []int{1, 2, 3}
doubled := mapSlice(nums, func(x int) int { return x * 2 })  // [2, 4, 6]

В практике senior-разработки я часто комбинирую эти инструменты для оптимизации: мониторю cap/len для избежания частых realloc, использую append в циклах с предвыделением памяти (через make с большой cap) и пишу утилиты для фильтрации/редьюса в отдельных пакетах для переиспользования. Для больших данных — интегрирую с sync для concurrency или внешними libs вроде github.com/google/go-container. Это обеспечивает производительность и читаемость кода.

Вопрос 2. На какие категории делятся итерационные методы массива, например мутирующие и не мутирующие, и в чём их отличие?

Таймкод: 00:01:00

Ответ собеседника: правильный. Мутирующие изменяют исходный массив, не мутирующие возвращают новый.

Правильный ответ:
В Go подход к итерации над массивами и слайсами отличается от языков вроде JavaScript или Python, где существуют встроенные итерационные методы (например, map, filter, forEach). Go подчеркивает простоту и контроль над памятью, поэтому итерация реализуется преимущественно через цикл for с ключевым словом range, а "методы" — это либо встроенные функции (как append), либо кастомные реализации в пользовательском коде или стандартных пакетах (например, slices в Go 1.21+). Классификация на мутирующие и не-мутирующие (immutable) категории применяется к этим подходам, но с нюансами: мутирующие операции изменяют исходный слайс напрямую (или его элементы), что может привести к side-effects и усложнить отладку в многопоточных сценариях, в то время как не-мутирующие возвращают новый слайс, сохраняя оригинал неизменным — это safer для функционального стиля программирования, тестирования и concurrency (например, с goroutines).

Основные категории итерационных подходов в Go:

Немутирующие (immutable) итерации:
Эти операции проходят по элементам слайса, но не изменяют его структуру или содержимое. Вместо этого они либо выполняют побочные действия (как логирование), либо создают новый слайс с трансформированными данными. Это минимизирует риски: оригинальный слайс остается стабильным, что полезно в системах с высокой нагрузкой, где мутации могут вызвать race conditions. В Go такие подходы реализуются через for range без присваивания обратно или через функции, возвращающие новый слайс.
- Пример базовой не-мутирующей итерации (аналог forEach для суммирования без изменения):
```
package main

import "fmt"

func main() {
    nums := []int{1, 2, 3, 4}
    sum := 0
    for _, v := range nums {  // _ игнорирует индекс; range создает копии значений для простых типов
        sum += v  // Только чтение, оригинал nums неизменен
    }
    fmt.Println(sum)  // Вывод: 10
}
```
- Кастомная функция для map (трансформация в новый слайс):
  Немутирующая, так как возвращает новый слайс; полезна для цепочек операций (chaining), как в функциональном программировании.
```
func mapInt(s []int, transform func(int) int) []int {
    result := make([]int, len(s))  // Предвыделяем память для эффективности
    for i, v := range s {
        result[i] = transform(v)
    }
    return result  // Новый слайс, оригинал s нетронут
}

// Использование
nums := []int{1, 2, 3}
doubled := mapInt(nums, func(x int) int { return x * 2 })  // doubled = [2, 4, 6]; nums все еще [1, 2, 3]
```
- Аналог filter (фильтрация в новый слайс):
```
func filterInt(s []int, pred func(int) bool) []int {
    var result []int  // Динамический рост через append
    for _, v := range s {
        if pred(v) {
            result = append(result, v)
        }
    }
    return result
}

evens := filterInt(nums, func(x int) bool { return x%2 == 0 })  // evens = [2]; nums неизменен
```
Преимущества: Легко тестировать (чистые функции), безопасно в параллельных вычислениях (например, с sync.WaitGroup для распределения итерации по goroutines). Недостаток: Дополнительное выделение памяти, что в Go оптимизируется через reuse пулов (например, sync.Pool для временных слайсов).
Мутирующие (in-place) итерации:
Эти операции изменяют исходный слайс или его элементы во время итерации. В Go это происходит, когда в цикле for range вы присваиваете значение обратно по индексу (поскольку range предоставляет копию значения для итерации, но индекс позволяет мутировать). Полезно для оптимизации памяти (без копирования), но требует осторожности: может привести к неожиданным изменениям в других частях кода, использующих тот же слайс, и усложняет concurrency (нужен sync.Mutex). Встроенные примеры — функции из пакета slices (Go 1.21+), такие как Sort, которые сортируют на месте.
- Пример мутации элементов в цикле (удвоение на месте):
```
nums := []int{1, 2, 3}
for i, _ := range nums {  // Используем индекс для мутации
    nums[i] *= 2  // Изменяем оригинал: nums теперь [2, 4, 6]
}
fmt.Println(nums)  // Вывод: [2 4 6]
```
  Важный нюанс: Для слайсов ссылок (например, []*int) мутация через значение в range изменит оригинал автоматически, но для value types (int, string) нужна индексация.
- Встроенный мутирующий метод: slices.Sort (Go 1.21+):
```
import "slices"

nums := []int{3, 1, 4, 1, 5}
slices.Sort(nums)  // Мутация на месте: nums = [1, 1, 3, 4, 5]
// slices.Reverse(nums) для реверса тоже мутирует
```
  Это эффективнее, чем создание нового слайса, особенно для больших данных (O(n log n) без лишней памяти).
- Опасность в concurrency: Если несколько goroutines итерируют мутирующий слайс, используйте каналы или locks:
```
import (
    "sort"
    "sync"
)

var mu sync.Mutex
// В goroutine:
mu.Lock()
sort.Ints(nums)  // Защищенная мутация
mu.Unlock()
```

Ключевые отличия и лучшие практики:

Изменение оригинала vs. новый объект: Мутации экономят память и время (идеально для performance-critical кода, как в серверах), но повышают риск ошибок (например, off-by-one в индексах или неожиданные side-effects). Немутирующие подходы способствуют declarative коду, легче рефакторить и debug, но увеличивают GC-pressure — в Go это решается через benchmarking (go test -bench) и профилирование.
Когда использовать что: Для простых трансформаций — не-мутирующие (чистота). Для сортировки/обновления — мутирующие (эффективность). В production всегда комбинируйте с тестами на мутации (например, с testing пакетом, проверяя, что оригинал не изменился для immutable). Для сложных сценариев интегрируйте с внешними библиотеками вроде github.com/manifoldco/promptui или реализуйте generics (Go 1.18+) для универсальных функций:
```
func Map[T, U any](s []T, f func(T) U) []U {
    result := make([]U, len(s))
    for i, v := range s {
        result[i] = f(v)
    }
    return result
}
```

Это делает код reusable и type-safe, подчеркивая силу Go в простых, но мощных абстракциях. В реальных проектах (микросервисы, ETL) я предпочитаю не-мутирующие для pipeline-обработки данных, чтобы избежать bottleneck'ов от shared state.

Вопрос 3. Как изменить массив и удалить элементы по условию, желательно в один проход?

Таймкод: 00:01:22

Ответ собеседника: неполный. Для удаления использовать filter, для изменения map, но в один проход не знаю, подсказали reduce.

Правильный ответ:
В Go массивы и слайсы не имеют встроенных методов вроде map с фильтрацией (как в JavaScript), поэтому комбинированные операции трансформации (изменения элементов) и удаления по условию реализуются через кастомные функции на основе цикла for range. Это позволяет выполнить всё в один проход (O(n) сложность по времени), избегая множественных итераций, что критично для производительности в высоконагруженных системах (например, обработка логов или ETL-пайплайнов). Основная идея: итерировать по исходному слайсу, проверять условие (predicate), если оно выполнено — трансформировать элемент (apply function) и добавлять в новый слайс через append. Это не-мутирующий подход по умолчанию (создаёт новый слайс, сохраняя оригинал), но можно адаптировать для мутации на месте, если память критична. Reduce здесь не самый подходящий (он агрегирует в скаляр, а не в коллекцию), лучше комбинация filter + map в одной функции.

Ключевые принципы реализации:

Один проход: Один цикл for _, v := range src — проверка условия, трансформация и append только для подходящих элементов. Это эффективнее отдельных filter и map, так как минимизирует доступ к памяти и GC.
Предвыделение памяти: Чтобы избежать множественных realloc в append, используйте make с оценочной ёмкостью (например, len(src)/2 для фильтрации). Go удваивает cap автоматически, но предвыделение снижает overhead.
Generics (Go 1.18+): Для type-safety и переиспользования — параметризуйте типы входа/выхода.
Условия и трансформация: Predicate (func(T) bool) решает, удалять ли; transform (func(T) U) меняет значение. Если трансформация не нужна для удаляемых — просто пропускаем.
Edge cases: Пустой слайс, все элементы удалены, все трансформированы; обработка nil-слайсов.

Базовый пример без generics (для int-слайса: удвоить чётные, удалить нечётные):

package main

import "fmt"

func transformAndFilter(src []int, pred func(int) bool, transform func(int) int) []int {
    // Оценочная ёмкость: предполагаем ~50% элементов пройдут фильтр
    result := make([]int, 0, len(src)/2)
    for _, v := range src {
        if pred(v) {  // Условие: сохранить?
            result = append(result, transform(v))  // Трансформировать и добавить
        }
    }
    return result  // Новый слайс, оригинал src неизменен
}

func main() {
    nums := []int{1, 2, 3, 4, 5, 6}
    // pred: чётные; transform: удвоить
    filteredTransformed := transformAndFilter(nums, func(x int) bool { return x%2 == 0 },
        func(x int) int { return x * 2 })
    fmt.Println(filteredTransformed)  // Вывод: [4 8 12]
    fmt.Println(nums)                 // Оригинал: [1 2 3 4 5 6] — неизменен
}

Здесь один проход: цикл обрабатывает каждый элемент ровно раз, проверяя и трансформируя только нужные. Если предикат всегда true — это чистый map; если трансформ identity (return x) — чистый filter.

Универсальная версия с generics (для любого типа T -> U):

package main

import "fmt"

func TransformAndFilter[T, U any](src []T, pred func(T) bool, transform func(T) U) []U {
    if src == nil {
        return nil  // Обработка edge case
    }
    result := make([]U, 0, len(src))  // Консервативная ёмкость
    for _, v := range src {
        if pred(v) {
            result = append(result, transform(v))
        }
    }
    return result
}

// Пример с strings: uppercase и удалить короткие (<3 символа)
func main() {
    words := []string{"go", "golang", "dev", "hello"}
    result := TransformAndFilter(words,
        func(s string) bool { return len(s) >= 3 },  // Фильтр
        func(s string) string { return strings.ToUpper(s) })  // Трансформ (импорт "strings")
    fmt.Println(result)  // Вывод: [GOLANG HELLO]
}

Generics делают функцию reusable для structs, pointers и т.д., без boxing/unboxing overhead.

Мутирующий вариант на месте (если нужно сэкономить память):
Для изменения и удаления в исходном слайсе используйте two-pointer технику (идея из C, адаптированная для Go): один указатель на "текущий" элемент, другой на "следующий для записи". Это O(n) без дополнительной памяти, но усложняет код и рискует off-by-one ошибками. Подходит для больших датасетов в memory-constrained окружениях (embedded или low-latency сервисы).
Пример: удвоить чётные и удалить нечётные на месте:

func mutateAndFilterInPlace(src []int) []int {
    if len(src) == 0 {
        return src
    }
    writeIdx := 0  // Позиция для записи
    for readIdx := 0; readIdx < len(src); readIdx++ {
        if src[readIdx]%2 == 0 {  // Условие
            if writeIdx != readIdx {  // Сдвиг, если пропускали
                src[writeIdx] = src[readIdx] * 2  // Трансформ и копия
            } else {
                src[writeIdx] *= 2  // Трансформ на месте
            }
            writeIdx++
        }
    }
    return src[:writeIdx]  // Обрезаем слайс до новой длины
}

func main() {
    nums := []int{1, 2, 3, 4, 5, 6}
    result := mutateAndFilterInPlace(nums)
    fmt.Println(result)  // [4 8 12]
    // nums теперь тоже изменён: слайсы — views, но здесь мы мутировали underlying array
}

Преимущество: Нет нового выделения (кроме возможного reslicing). Недостаток: Изменяет оригинал, что может сломать другие ссылки на слайс; в concurrency — нужен lock. Используйте редко, только после benchmark (go test -bench=.).

Лучшие практики и оптимизации:

Производительность: Всегда бенчмаркьте с testing.B — append в цикле эффективен, но для миллионов элементов используйте fixed-size buffer или sync.Pool для reuse слайсов. В Go 1.21+ пакет slices имеет Compact для удаления nil/zero, но для custom — ручной подход лучше.
Когда комбинировать: В пайплайнах данных (например, обработка JSON в API) цепочка не-мутирующих функций (filter -> map -> reduce) предпочтительнее, но один проход выигрывает, если трансформация простая. Для сложных — разбейте на этапы для читаемости.
Concurrency: Для параллельного обработки больших слайсов разбейте на chunks (используйте runtime.NumCPU() goroutines), собирая результаты в channel или WaitGroup-protected слайс. Пример: fan-out/fan-in паттерн.
Ошибки избегать: Не мутируйте слайс во время range-итерации (паника!); всегда range по копии или индексам. Тестируйте с reflect.DeepEqual для проверки результатов. В production-коде добавьте логику для overflow (редко, но cap может исчерпаться).

Этот подход подчёркивает силу Go: контроль над эффективностью без магии, позволяя масштабировать от простых скриптов до distributed систем, где один проход может сэкономить секунды на миллиардах элементов.

Вопрос 4. Как создать объект в JavaScript?

Таймкод: 00:02:21

Ответ собеседника: правильный. В фигурных скобках или через new Object.

Правильный ответ:
В JavaScript объекты — это фундаментальные структуры данных, представляющие коллекции ключ-значение (properties), где ключи — строки или символы (Symbols), а значения — любые типы (примитивы, функции, другие объекты). Создание объектов возможно несколькими способами, каждый с нюансами по производительности, читаемости и прототипному наследованию. JavaScript использует прототипно-ориентированную модель (prototype chain), где все объекты наследуют от Object.prototype по умолчанию, если не указано иное. Это позволяет делегировать свойства и методы вверх по цепочке, оптимизируя память. На senior-уровне важно понимать, когда использовать literal (для простоты), конструкторы (для классов/ES6+), фабрики (для инкапсуляции) или Object.create (для custom прототипов), чтобы избежать антипаттернов вроде глобального загрязнения или ненужных инстансов.

Основные способы создания объектов:

Объектный литерал (Object Literal) — наиболее распространённый и эффективный:
Используйте фигурные скобки {} для inline-создания. Это shorthand-нотация, компилируемая в вызов Object.create(null) или подобное под капотом (в зависимости от движка, как V8 в Node.js/Chrome). Подходит для конфигов, данных API или простых DTO. Ключи могут быть строками, вычисляемыми (в скобках [expr]), и свойствам присваиваются значения через : или ES6 shorthand (если ключ = переменной).
Преимущества: Быстро, читаемо, нет overhead конструктора. Недостатки: Нет приватных полей без Symbol/weakMap.
Пример базового создания:
```
// Простой объект
const person = {
    name: 'Alice',
    age: 30,
    greet: function() {  // Метод как функция
        return `Hello, I'm ${this.name}`;
    }
};
console.log(person.greet());  // Вывод: "Hello, I'm Alice"

// ES6 shorthand для свойств и методов
const name = 'Bob';
const age = 25;
const user = { name, age,  // Автоматически name: name, age: age
               login() { return `${name} logged in`; }  // Метод shorthand
             };
console.log(user.login());  // Вывод: "Bob logged in"
```
Вычисляемые ключи (ES6+):
```
const dynamicKey = 'id';
const obj = {
    [dynamicKey]: 123,  // Ключ 'id' с значением 123
    [`fullName_${Date.now()}`]: 'Dynamic Value'
};
console.log(obj.id);  // 123
```
В production: Используйте для immutable данных с Object.freeze(obj) или Object.seal(obj) для предотвращения мутаций.
Через конструктор new Object() или Object.create():
- new Object(): Создаёт пустой объект, эквивалент {}. Редко используется напрямую, но полезен в циклах или когда нужно динамически строить.
```
const emptyObj = new Object();  // {}
emptyObj.prop = 'value';  // Добавление свойств
```
- Object.create(proto, descriptors): Создаёт объект с заданным прототипом (proto) и опциональными дескрипторами свойств (enumerable, writable и т.д.). Идеально для композиции или когда нужно делегировать методы без наследования класса. Это базовый механизм JS, позволяющий создавать "голые" объекты без Object.prototype.
  Пример с custom прототипом:
```
const proto = {
    sayHello() {
        return `Hi from prototype: ${this.name}`;
    }
};
const person = Object.create(proto, {
    name: { value: 'Charlie', writable: true, enumerable: true }  // Дескриптор
});
console.log(person.sayHello());  // Вывод: "Hi from prototype: Charlie"
console.log(Object.getPrototypeOf(person) === proto);  // true
```
  Использование: В фреймворках (React contexts) или для mixin-паттернов. Object.create(null) создаёт объект без прототипа — полезно для словарей (maps), чтобы избежать ложных срабатываний на hasOwnProperty (поскольку null прототип не имеет встроенных методов).

Через конструкторные функции (pre-ES6) или классы (ES6+):
Для создания множества похожих объектов используйте функции-конструкторы или class. Это инстанцирует объекты с this контекстом и устанавливает прототип. Классы — syntactic sugar над прототипами, но с улучшениями (private fields #, static методы).
Конструкторная функция:

function Person(name, age) {
    this.name = name;
    this.age = age;
    this.greet = function() { return `Hello, ${this.name}`; };
}
const alice = new Person('Alice', 30);
console.log(alice.greet());  // "Hello, Alice"
// Прототип: Person.prototype (методы лучше вешать туда для shared)
Person.prototype.walk = function() { return `${this.name} walks`; };

ES6 класс:

class User {
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }
    greet() {  // Instance method на прототипе
        return `Hello, I'm ${this.name} (${this.age})`;
    }
    static createGuest() {  // Static method
        return new User('Guest', 0);
    }
}
const bob = new User('Bob', 25);
console.log(bob.greet());  // "Hello, I'm Bob (25)"
const guest = User.createGuest();

Private fields (ES2022+):

class BankAccount {
    #balance = 0;  // Приватное поле
    constructor(initial) { this.#balance = initial; }
    deposit(amount) { this.#balance += amount; }
    getBalance() { return this.#balance; }  // Только геттер
}

Когда использовать: Для моделей данных в приложениях (OOP стиль). Избегайте в простых случаях — overhead на прототип. В Node.js/бэкенде (с Express) классы хороши для middleware или сервисов.

Фабричные функции (Factory Functions) — функциональный подход:
Возвращают объект без new, инкапсулируя создание. Полезны для dependency injection или когда классы overkill.

function createPerson(name, age) {
    return {
        name,
        age,
        greet: () => `Hello, ${name}`,  // Arrow для lexical this, но осторожно с контекстом
        // Closure для приватности
        _secret: 'hidden',  // Не enumerable, но доступен
        getSecret() { return this._secret; }
    };
}
const charlie = createPerson('Charlie', 35);
console.log(charlie.greet());  // "Hello, Charlie"

Преимущества: Нет this pitfalls, легко тестировать. В modern JS (с modules) — альтернатива классам для stateless объектов.

Ключевые отличия и лучшие практики:

Производительность: Литералы — fastest (no function call). Конструкторы — медленнее из-за prototype setup. Бенчмаркьте с performance.now() или tools вроде jsPerf.
Наследование и прототипы: Всегда проверяйте цепочку с Object.getPrototypeOf(obj) или obj.__proto__ (нестандартно, используйте Reflect). Для deep clone — structuredClone(obj) (modern) или lodash.cloneDeep.
Immutable объекты: В React/Redux — используйте {...obj, newProp: value} (spread) для shallow copy. Для deep — Immer или custom reducers.
Edge cases: Создание с Symbol keys: const sym = Symbol('key'); obj[sym] = 'value'; (не перечисляемы). Избегайте new Object() в loops — лучше push в массив литералов. В async коде (Promises) объекты передавайте по ссылке, но клонируйте для мутаций.
В контексте full-stack (с Go бэкендом): В API (JSON) объекты сериализуются naturally; в Go marshal/unmarshal с encoding/json. Для валидации — Joi или Zod на JS, struct tags на Go.

Выбор способа зависит от контекста: литералы для данных, классы для бизнес-логики, фабрики для модульности. В крупных проектах (SPA или Node сервисы) стандартизируйте с ESLint rules (no-new-object) и типизируйте с TypeScript для safety. Это обеспечивает scalable, maintainable код без legacy traps вроде constructor pitfalls.

Вопрос 5. Какой тип данных у объекта и чем отличаются простые типы от сложных?

Таймкод: 00:02:37

Ответ собеседника: неполный. Объект - это сложный тип, простые как стринг и boolean, сложные включают объекты и массивы, потому что ссылочные.

Правильный ответ:
В JavaScript все типы данных делятся на две основные категории: примитивные (primitive) и ссылочные (reference, или non-primitive/complex). Объекты (включая массивы, функции, даты и т.д.) относятся к ссылочным типам, и оператор typeof для них возвращает 'object' (за исключением функций, где typeof даёт 'function' — это историческая особенность JS, но функции тоже объекты). Массивы специально проверяются через Array.isArray() или instanceof Array, поскольку typeof [] тоже 'object'. Это фундаментальное разделение влияет на хранение в памяти, передачу аргументов, мутабельность и поведение при присваивании/копировании. На senior-уровне понимание этих отличий критично для избежания багов в concurrency (Web Workers), оптимизации памяти (в Node.js с V8 heap) и написания чистого кода (immutability в React/Redux). JS — динамически типизированный язык без строгой типизации (но с TypeScript для помощи), где примитивы boxed в объекты под капотом при необходимости (autoboxing).

Примитивные типы (Primitives):
Это базовые, неизменяемые (immutable) значения, хранящиеся напрямую в стеке (stack) памяти — как простые атомарные единицы без внутренней структуры. Они передаются по значению (by value): при присваивании или передаче в функцию копируется само значение, без ссылок. Всего 7 примитивных типов (ES2020+):

string: Строки, например 'hello' или "world".
number: Числа (IEEE 754 double, включая NaN, Infinity).
bigint: Большие целые (для crypto/math, суффикс n, как 123n).
boolean: true/false.
undefined: Неинициализированные переменные (по умолчанию).
symbol: Уникальные идентификаторы (для приватных ключей, ES6+).
null: Намеренное пустое значение (исторически typeof null === 'object', но это баг, не тип).

Примитивы immutable: попытка изменения создаёт новый (например, let s = 'hi'; s[0] = 'b'; — s остаётся 'hi', так как строки не мутируют). Это обеспечивает thread-safety и предсказуемость в асинхронном коде.
Пример проверки и поведения:

let str = 'hello';  // Примитив string
console.log(typeof str);  // 'string'

let num = 42;
let copyNum = num;  // Копирование значения: 42
num = 100;
console.log(copyNum);  // 42 — оригинал не изменился

let bool = true;
function primitiveFn(p) { p = false; }  // Передача по значению
primitiveFn(bool);
console.log(bool);  // true — функция не мутировала оригинал

В V8 (Chrome/Node) примитивы занимают фиксированный размер (например, 8 байт для number), что быстро для GC. Для строк — есть интернирование (string interning) для оптимизации равенств.

Ссылочные типы (Reference Types, или Objects):
Это сложные структуры, хранящиеся в куче (heap) памяти, с ссылкой (pointer) на них в стеке. Передаются по ссылке (by reference): присваивание или аргумент копирует указатель, так что все переменные ссылаются на один объект — мутация через одну изменит все. Объекты mutable по умолчанию, что позволяет динамически добавлять/удалять свойства (obj.prop = value; delete obj.prop;). Включают:

Обычные объекты {}.
Массивы [] (специализированные объекты с numeric keys и length).
Функции (вызываемые объекты).
Встроенные: Date, RegExp, Map, Set, WeakMap, WeakSet, Proxy, TypedArrays (ES6+).
И даже примитивы в boxed форме: new String('hi') — это объект, а не примитив.

typeof obj === 'object' для большинства, но для уточнения используйте instanceof (проверяет prototype chain) или duck typing (obj.hasOwnProperty). Массивы — объекты, но с [[Class]] 'Array' (внутренний слот).
Пример:

let obj = { name: 'Alice' };  // Ссылочный тип object
console.log(typeof obj);  // 'object'

let arr = [1, 2, 3];  // Массив — тоже object
console.log(typeof arr);  // 'object'
console.log(Array.isArray(arr));  // true

let copyObj = obj;  // Копирование ссылки
obj.name = 'Bob';
console.log(copyObj.name);  // 'Bob' — оба изменились

function refFn(r) { r.name = 'Charlie'; }  // Мутация по ссылке
refFn(obj);
console.log(obj.name);  // 'Charlie' — оригинал мутирован

Функции как объекты:

function fn() { return 'func'; }
console.log(typeof fn);  // 'function'
console.log(fn.toString === Function.prototype.toString);  // true — наследует от Function
fn.customProp = 'attached';  // Можно добавлять свойства
console.log(fn.customProp);  // 'attached'

Ссылки позволяют shared state, полезно для graphs (DOM nodes), но опасно: неожиданные мутации в коллбэках или closures. Для immutable — используйте Object.freeze(obj) (shallow), Object.seal(obj) (запрет добавления/удаления) или библиотеки вроде Immutable.js.

Ключевые отличия простых и сложных типов:

Хранение и память: Примитивы — direct value в stack (быстро, GC-free для locals). Ссылочные — pointer в stack + data в heap (GC управляет heap, может вызвать паузы в long-running apps как Node servers).
Передача и копирование: By value vs. by reference. Для deep copy объектов — JSON.parse(JSON.stringify(obj)) (но теряет функции/dates), structuredClone(obj) (modern, ES2022+), или lodash.cloneDeep.
Мутабельность: Primitives — нет (создаётся новый при "изменении", как s += '!'). Objects — да, но можно сделать immutable. Это влияет на equality: ==/=== для primitives сравнивает value, для objects — references (два {} не равны, даже если содержимое идентично). Используйте Object.is() или custom deepEqual.
Операции и методы: Primitives имеют autoboxing (e.g., 'hi'.toUpperCase() — создаёт String object temporarily). Objects — полные API (e.g., obj.hasOwnProperty('key')). Нет перегрузки, но Proxy позволяет meta-programming.
Производительность и pitfalls: Primitives faster для loops/conditions. Objects — slower из-за indirection; в arrays избегайте mixing primitives/objects для оптимизации (V8 JIT). Common bug: null typeof 'object' — всегда проверяйте obj === null. В async (Promises) primitives safe, objects — race conditions на shared refs.

Пример сравнения в практике (React-like state update):

// Неправильно: мутация shared object
let state = { user: { name: 'Alice' } };
function updateName(newState, name) {
    newState.user.name = name;  // Мутация!
}
updateName(state, 'Bob');
console.log(state.user.name);  // 'Bob' — side-effect

// Правильно: immutable update (spread для shallow copy)
function updateNameImmutable(state, name) {
    return {
        ...state,
        user: { ...state.user, name }  // Новый объект
    };
}
let newState = updateNameImmutable(state, 'Bob');
console.log(newState.user.name);  // 'Bob'
console.log(state.user.name);     // 'Alice' — оригинал safe

Лучшие практики для senior-разработки:

Типизация: В TS используйте interface для objects, type для unions primitives. Runtime checks: zod или io-ts для валидации.
Оптимизация: В loops — primitives preferred; для objects — Map/Set вместо {} для O(1) lookups (если keys non-string). В Node — monitor heap с process.memoryUsage().
Immutability first: В stateful apps (Redux, Vue) — avoid mutations с immer или pure functions. Для equality — JSON.stringify в keys (но hash collisions).
Edge cases: Symbol/WeakMap — non-enumerable refs; BigInt interop с objects. В WebAssembly/JS interop — primitives marshal faster. Тестируйте с Jest: expect(typeof obj).toBe('object').

Это разделение — основа JS семантики, позволяющая баланс между простотой (primitives) и выразительностью (objects). В full-stack (с Go API) primitives маппятся напрямую в JSON, objects — как structs, но watch за circular refs в serialization. Понимание помогает писать robust код, scalable от браузера до сервера.

Вопрос 6. Что такое копии объектов, зачем они нужны, в чём разница между глубоким и неглубоким копированием, и как сделать глубокую копию?

Таймкод: 00:03:36

Ответ собеседника: неполный. Копии глубокие и неглубокие; неглубокое копирует верхний уровень, глубокое - все; зачем - чтобы избежать изменения оригинала через ссылку; глубокую не делал, но знаю через JSON.stringify и parse.

Правильный ответ:
В JavaScript копии объектов — это процесс создания дубликатов ссылочных типов (объектов, массивов, функций), чтобы работать с независимыми версиями данных без unintended мутаций оригинала. Поскольку объекты передаются по ссылке (как объяснялось ранее), простое присваивание (let copy = original) создаёт лишь новый указатель на тот же объект в heap, приводя к shared state и потенциальным багам (например, в React state updates или multi-threaded Web Workers). Копии необходимы для immutability (предсказуемость), тестирования (изолированные mocks), concurrency (избежание race conditions) и функционального программирования (pure functions без side-effects). Без копий код становится fragile: изменение в одном месте (callback, reducer) ломает другие. В production это критично для scalability — например, в Node.js серверах с async handlers или SPA с global state (Redux), где мутации приводят к infinite re-renders или memory leaks.

Копии делятся на неглубокие (shallow) и глубокие (deep), в зависимости от обработки nested структур (вложенных объектов/массивов). Shallow copy дублирует только верхний уровень (top-level properties), оставляя вложенные как ссылки на оригинал. Deep copy рекурсивно дублирует всю структуру, создавая полностью независимый граф объектов. Выбор зависит от глубины: shallow faster и memory-efficient для flat объектов, deep — safer для nested data (JSON responses, trees), но дороже по времени (O(n) где n — все узлы) и памяти (дублирует всё).

Разница между shallow и deep копированием:

Shallow copy:
Копирует enumerable own properties верхнего объекта, но для nested — копирует ссылки. Изменение nested в копии мутирует оригинал. Полезно для простых случаев (configs без вложений), но pitfalls: неожиданные мутации в chains (e.g., obj.nested.prop = value). Не копирует non-enumerable (Symbols, getters), prototype chain или methods (если не custom).
Пример проблемы:
```
const original = { a: 1, nested: { b: 2 } };
const shallowCopy = { ...original };  // ES6 spread — shallow
shallowCopy.nested.b = 3;  // Мутация!
console.log(original.nested.b);  // 3 — оригинал изменён
console.log(shallowCopy.a);      // 1 — top-level скопировано
```
Другие способы shallow: Object.assign(target, source) (мутирует target, возвращает его; для copy — пустой {} как target) или Array.prototype.slice() для массивов. Object.assign merges multiple sources, полезно для defaults.
Deep copy:
Рекурсивно копирует все уровни, создавая новые объекты/массивы для каждого nested. Изменения в копии полностью изолированы. Идеально для cloning trees (DOM, AST), data serialization или state snapshots. Минусы: Не копирует functions (они references), circular references (loops в graph — вызовет stack overflow без handler), Dates/RegExp (нужен custom), или non-serializable (WeakMaps). Время: exponential для deep nests, так что benchmark с performance.now().
Пример:
```
const original = { a: 1, nested: { b: 2, deeper: [3, { c: 4 }] } };
// Deep copy (показано ниже)
const deepCopy = structuredClone(original);  // Modern way
deepCopy.nested.b = 3;
deepCopy.nested.deeper[1].c = 5;
console.log(original.nested.b);       // 2 — оригинал нетронут
console.log(original.nested.deeper[1].c);  // 4 — полностью изолировано
```
Shallow vs. deep в практике: В Redux reducers — shallow для perf (shallowEqual checks), deep для complex mutations. В concurrency (Workers) — deep, чтобы избежать shared memory issues (Structured Clone Algorithm в postMessage — built-in deep clone).

Как сделать глубокую копию:
Нет built-in до ES2022, но несколько подходов, от простых (с ограничениями) до robust (custom). Выбирайте по контексту: JSON для serializable data, structuredClone для modern browsers/Node 17+, recursive для control.

JSON.stringify + JSON.parse — простой, но limited:
Сериализует в строку и парсит обратно. Работает для plain objects/arrays с primitives, но теряет: functions (становятся null), undefined/Symbol (игнор), Dates (to string), NaN/Infinity (null), circular refs (error). Полезно для API data (JSON-safe).
Пример:
```
const original = { a: 1, nested: { b: [2, undefined, { c: 'date' }] } };
const deepCopy = JSON.parse(JSON.stringify(original));
deepCopy.nested.b[1] = 'replaced';  // undefined -> 'replaced', но original.b[1] undefined
console.log(original.nested.b[1]);   // undefined — изолировано, но потеряли типы
// Pitfall: Date d = new Date(); -> string в copy
```
Overhead: String conversion slow для large objects; используйте в non-perf paths.

Structured Clone Algorithm (modern, ES2022+):
Built-in deep clone в browsers (postMessage, IndexedDB) и Node 17+. Копирует: primitives, objects/arrays, Dates (как new Date), RegExp, Maps/Sets, TypedArrays, но не functions, DOM nodes, circular (error), или non-clonable (e.g., some proxies). Safer чем JSON, handles more types.
Пример:

const original = { 
    date: new Date('2023-01-01'),
    arr: [1, { nested: new Map([['key', 'value']]) }],
    regex: /test/g
};
const deepCopy = structuredClone(original);  // Polyfill для old env: https://github.com/joyent/node/tree/main/lib/internal/structured_clone
deepCopy.date.setFullYear(2024);  // Мутация копии
console.log(original.date.getFullYear());  // 2023 — intact
console.log(deepCopy.arr[1].nested.get('key'));  // 'value' — Map скопирован
// В Node: const { structuredClone } = require('util'); (17+)

Лучший default для web/apps: Fast, spec-compliant. Для circular — custom handler.

Custom recursive функция — полный контроль:
Для scenarios с functions, circular или custom types: recurse по keys/values, handle arrays/objects specially. Используйте WeakSet для circular detection. Это O(n), но flexible; интегрируйте в utils lib.
Пример базовой recursive deep clone:

function deepClone(obj, visited = new WeakMap()) {
    if (obj === null || typeof obj !== 'object') return obj;  // Primitives
    if (visited.has(obj)) return obj;  // Circular: return ref or throw
    visited.set(obj, true);

    if (Array.isArray(obj)) {
        const copy = [];
        for (let i = 0; i < obj.length; i++) {
            copy[i] = deepClone(obj[i], visited);
        }
        return copy;
    }

    const copy = {};
    for (let key in obj) {
        if (obj.hasOwnProperty(key)) {
            copy[key] = deepClone(obj[key], visited);
        }
    }
    // Handle Symbols: Reflect.ownKeys(obj)
    // Functions: copy[key] = obj[key]; // Shallow for methods
    // Dates: new Date(obj.getTime())
    // Etc. — extend для types
    return copy;
}

const original = { a: 1, nested: { b: function() {} }, circular: null };
original.circular = original;  // Circular
const deepCopy = deepClone(original);
deepCopy.nested.b = () => 'cloned';  // Function shallow, но ok
console.log(deepCopy.circular === deepCopy);  // true — handled circular

Enhancements: Для Maps/Sets — new Map(obj.entries()), для Dates — new Date(obj). Для perf — memoization с WeakMap. В libraries: lodash.cloneDeep (robust, handles most cases).

Другие инструменты:
- Lodash/Ramda: _.cloneDeep(obj) — battle-tested, handles edge cases.
- Immer: Не clone, но produces drafts для immutable updates (e.g., produce(obj, draft => { draft.nested = 3; }) — returns new obj). Идеально для state (Redux Toolkit).
- PostMessage hack (legacy): window.postMessage(obj, '*').data — uses structured clone, но insecure.

Лучшие практики и pitfalls:

Когда shallow достаточно: Flat data или когда nested intentionally shared (performance). Проверяйте с Object.isFrozen или tests (expect(original).not.toBe(copy); deepEqual(copy.nested, original.nested)).
Perf considerations: Deep clone expensive — avoid в hot paths (loops, renders); используйте id-based refs (e.g., { id: 1, data: shared }) или immutable libs. Monitor с Chrome DevTools heap snapshots.
Concurrency: В Workers — structuredClone mandatory для transfer; в Node clusters — serialize via JSON.
Testing: В Jest: expect(deepCopy).toEqual(original) (structural), но toStrictEqual для types. Mock clone в utils.
Common errors: Забыть про prototypes (clone не копирует proto — используйте Object.create для chain). Circular без detection — RecursionError. Functions/Date loss в JSON. В TS: Preserve types с generics.

В full-stack: На фронте (React) — deep для props; на бэке (Go equiv: json.Unmarshal(Marshal(obj))) — similar limitations. Понимание копий — ключ к bug-free, scalable JS, особенно в large apps где state complexity растёт exponentially.

Вопрос 7. Как из массива строк создать объект, где строки станут ключами?

Таймкод: 00:05:19

Ответ собеседника: неполный. Пройтись по массиву forEach и динамически добавить свойства через квадратные скобки.

Правильный ответ:
В JavaScript преобразование массива строк в объект, где элементы массива становятся ключами (properties), — распространённая операция для создания словарей (hash maps), фильтров (e.g., наличие в set) или индексации данных. Поскольку ключи объектов в JS — строки (или Symbols), строки из массива идеально подходят: они автоматически используются как keys без приведения типов. Значения для ключей можно задать по умолчанию (e.g., true для Set-подобной структуры, null/undefined для sparse, или индекс/сама строка для хранения). Это полезно в сценариях вроде unique lookups (O(1) access vs. O(n) в массиве), state management (React keys), или API data processing (grouping strings). Если массив содержит дубликаты, последний элемент перезапишет предыдущие (объекты не мультимапы). Для non-string keys или order preservation лучше Map, но для строк объект — efficient (V8 оптимизирует как hash table). Edge cases: пустой массив → пустой объект; null/undefined в массиве → пропуск или error handling; большие массивы — watch memory (objects grow dynamically).

Основные способы реализации:
Выберите по стилю: imperative (forEach/цикл для мутации) для простоты, functional (reduce) для immutability и chaining, или built-in (Object.fromEntries) для conciseness (ES2019+). Все O(n) по времени, но reduce/fromEntries cleaner и testable. Избегайте мутации внешнего объекта в production — возвращайте новый.

Imperative подход с forEach или for...of (как упомянул собеседник):
Итерируйте по массиву, добавляя свойства через computed property syntax ([key]: value). ForEach мутирует target объект (нужно создать заранее). Полезно, если нужно side-effects (e.g., logging), но в modern JS prefer declarative.
Пример: Создать { str: true } для quick lookup (e.g., isInArray?):
```
const strings = ['apple', 'banana', 'apple', 'cherry'];  // Дубликат 'apple' перезапишется
const obj = {};  // Target объект
strings.forEach(str => {
    if (str) {  // Handle falsy (empty string ok, но null/undef — skip)
        obj[str] = true;  // Значение: true для Set-like
    }
});
console.log(obj);  // { apple: true, banana: true, cherry: true }
console.log('apple' in obj);  // true — O(1) check
// Альтернатива: for...of для break/continue
const obj2 = {};
for (const str of strings) {
    obj2[str] = str.length;  // Значение: длина строки
}
console.log(obj2);  // { apple: 5, banana: 6, cherry: 6 }
```
Pitfall: ForEach не возвращает значение — всегда создавайте obj заранее. Для больших массивов (>10k) — benchmark, так как property addition amortized O(1), но initial hash setup.

Functional подход с reduce (рекомендуемый для purity):
Reduce аккумулирует объект, начиная с {} (initialValue). Это immutable: возвращает новый объект без мутации входа. Идеально для pipelines (e.g., filter -> reduce -> map). Handles edge cases gracefully.
Пример базовый:

const strings = ['apple', 'banana', 'cherry'];
const obj = strings.reduce((acc, str) => {
    if (str !== null && str !== undefined) {  // Validation
        acc[str] = true;  // Или acc[str] = acc[str] || index++ для unique
    }
    return acc;  // Обязательно return!
}, {});  // Initial: пустой объект
console.log(obj);  // { apple: true, banana: true, cherry: true }

Расширенный: С индексами или custom value:

const withIndex = strings.reduce((acc, str, index) => {
    acc[str] = index;  // Ключ: str, значение: index (дубликаты перезапишут)
    return acc;
}, {});
console.log(withIndex);  // { apple: 0, banana: 1, cherry: 2 } (если no dups)
// Для уникальных: используйте Set сначала
const uniqueObj = [...new Set(strings)].reduce((acc, str) => {
    acc[str] = str.toUpperCase();  // Transform value
    return acc;
}, {});

Преимущества: Легко compose (e.g., strings.filter(Boolean).reduce(...)), testable (pure function). В Redux-like reducers — аналогично для state transforms.

Built-in: Object.fromEntries (ES2019+, modern browsers/Node 12+):
Преобразует iterable (array of [key, value] pairs) в объект. Сначала map массив строк в pairs, затем fromEntries. Concise, performant (native impl). Для polyfill — Babel или manual reduce.
Пример:

const strings = ['apple', 'banana', 'cherry'];
const obj = Object.fromEntries(
    strings.map(str => [str, true])  // [[key, value], ...]
);
console.log(obj);  // { apple: true, banana: true, cherry: true }
// С transform: strings.map(str => [str, str.length])
const lengths = Object.fromEntries(strings.map(str => [str, str.length]));
console.log(lengths);  // { apple: 5, banana: 6, cherry: 6 }
// Edge: Пустой массив → {}
const empty = Object.fromEntries([]);
console.log(empty);  // {}

С Map промежуточно (если need order или non-strings):

const map = new Map(strings.map(str => [str, true]));  // Preserves insertion order
const obj = Object.fromEntries(map);  // To object

Это fastest для simple cases: Native code, no loop overhead. В TS: Record<string, boolean> type.

Ключевые отличия и лучшие практики:

Vs. Map: Объекты для string keys — fine, но Map лучше для any keys (numbers, objects), iteration order (ES2015+ objects unordered, но V8 stable) и size property. Переключайтесь, если keys dynamic/non-string: new Map(strings.map(str => [str, true])).
Дубликаты и uniqueness: Объекты overwrite — для multi-values используйте arrays: acc[str] = [...(acc[str] || []), value]. Или Set для keys only.
Производительность: Для 1M+ элементов — reduce/fromEntries > forEach (functional avoids mutation bugs). Test с console.time('build'). В loops — pre-allocate если possible (но objects dynamic). GC: Objects hold refs — deep clone если need detach.
Immutability и safety: Всегда возвращайте новый obj; в React — useCallback для memo. Validate input: strings.filter(s => typeof s === 'string'). Для nulls: strings.flatMap(s => s ? [[s, true]] : []).
Common pitfalls: Квадратные скобки [str] — да, для dynamic keys (str.toString() если non-string). Empty strings как keys — ok ('' : true). Circular? Нет, linear. В async (Promises.all) — await map, then reduce.
В контексте apps: В API parsing (fetch JSON → strings → obj для lookup), или UI (tags array → selected filter). С Lodash: _.keyBy(strings, Math.random) но custom. Тестируйте: expect(obj).toEqual({ apple: true, ... }).

Этот паттерн — основа для data structures в JS, scalable от utils до core logic. В full-stack (Go equiv: map[string]bool) — аналогично, но JS objects flexible для runtime keys. Используйте reduce/fromEntries для clean, senior-level code — подчёркивает functional paradigms без boilerplate.

Вопрос 8. Какие логические операторы есть в JavaScript и что вернёт выражение вроде пустая строка || 1 || [] и '' && 1 && []?

Таймкод: 00:07:13

Ответ собеседника: правильный. Операторы || (или), && (и), ! (не); первое вернёт 1, второе - пустую строку как false.

Правильный ответ:
В JavaScript логические операторы — это инструменты для условных проверок и short-circuit вычислений, которые не только булевы (true/false), но и возвращают операнды (не обязательно boolean). Это отличает JS от языков вроде C++, где результат всегда bool. Операторы работают с truthy/falsy значениями: falsy — значения, преобразуемые к false в boolean context (false, 0, -0, 0n, '', null, undefined, NaN); truthy — всё остальное (включая [], {}, ' ', 1, non-empty strings, objects). Short-circuit — ключевой механизм: || и && оценивают операнды слева направо и останавливаются при определённом условии, возвращая текущий операнд (экономит perf, избегает side-effects в функциях). Это полезно для defaults (|| как fallback), guards (&& для conditional exec) и chaining. На senior-уровне важно понимать pitfalls: short-circuit не меняет тип (возвращает operand), может привести к unexpected results с non-bool (e.g., [] truthy, несмотря на empty), и в strict equality (===) результат не bool. В production (React conditions, API guards) — комбинируйте с ?? (nullish) для precise null/undef handling, избегая falsy pitfalls (e.g., 0 || 'default' → 'default', но 0 valid).

Основные логические операторы:

Логическое ИЛИ (||) — OR:
expr1 || expr2 (или цепочка a || b || c). Возвращает первый truthy операнд; если все falsy — последний (falsy). Эквивалентно: if (expr1) return expr1; else return expr2. Полезно для defaults: const name = userInput || 'Anonymous'; (но pitfalls с falsy non-null, как empty string). Не путать с bitwise | (bitwise OR).
Пример:
```
const a = '' || 42 || null;  // '' falsy → 42 (truthy, short-circuit)
console.log(a);  // 42 (number, не bool)

// Side-effect: Ленивая оценка
const risky = () => { console.log('expensive call'); return 'value'; };
console.log('' || risky());  // Вывод: "expensive call", затем 'value' (вызвано, так как '' falsy)
```
В chains: Останавливается на первом truthy, игнорируя rest (perf win для large expr).
Логическое И (&&) — AND:
expr1 && expr2 (или цепочка). Возвращает первый falsy операнд; если все truthy — последний (truthy). Эквивалентно: if (!expr1) return expr1; else return expr2. Идеально для guards: user && user.login() (выполнит login только если user truthy). Short-circuit предотвращает ошибки (e.g., null.prop error).
Пример:
```
const b = 0 && 'hello' && true;  // 0 falsy → возвращает 0 (short-circuit)
console.log(b);  // 0

// Guard в React-like
const condition = userId && fetchUser(userId);  // Если userId falsy — не вызовет fetchUser
condition?.then(user => console.log(user.name));  // Optional chaining для safety
```
В chains: Останавливается на первом falsy; если все truthy — last.
Логическое НЕ (!) — NOT:
!expr — инвертирует truthiness: truthy → false, falsy → true. Unary, возвращает boolean. Двойное !! — explicit toBoolean: !!obj → true/false. Полезно для negation: if (!isValid) return;.
Пример:
```
console.log(!'');     // true ('' falsy → inverted)
console.log(![]);     // false ([] truthy → inverted to false)
console.log(!!NaN);   // false (NaN falsy → !! to false)
console.log(!0);      // true
```
Pitfall: ![] === true? Нет, ![] = false. Используйте для bool coercion, но prefer explicit checks (typeof, Array.isArray).
Nullish coalescing (??) — ES2020, modern:
expr1 ?? expr2 — возвращает expr2 только если expr1 null/undefined (nullish), игнорируя другие falsy (0, '', false). Фиксит || pitfalls: const count = input ?? 0; (0 valid, не fallback). Short-circuit аналогично.
Пример:
```
const c = '' ?? 'default';  // '' not nullish → ''
const d = null ?? 'default';  // null → 'default'
console.log(c, d);  // '' 'default'
```
В Node 14+/browsers: Native. Polyfill: expr1 != null ? expr1 : expr2. Идеально для API defaults (JSON может иметь null, но не empty strings).
Другие related (не чисто logical, но часто с ними):
- Optional chaining (?. ) и nullish (?.??): obj?.prop ?? 'default' — safe access.
- Bitwise: & (AND), | (OR), ^ (XOR), ~ (NOT) — для ints, не truthy-based.
- Тернарный ? : — conditional, но не logical operator.

Анализ конкретных выражений:
Эти примеры иллюстрируют short-circuit и truthy/falsy. Важно: Результат — operand, не bool; используйте !! если need explicit boolean.

'' || 1 || []:
- '' (empty string) — falsy → short-circuit не останавливается, идёт к 1.
- 1 — truthy → возвращает 1 (short-circuit, [] не оценивается).
  Результат: 1 (number).
```
console.log('' || 1 || []);  // 1
// Если все falsy: '' || null || 0 → 0 (последний)
```
Почему [] не reached? Perf: Избегает создания empty array если не нужно. В практике: config || defaults || {} — chain для fallback.
'' && 1 && []:
- '' — falsy → short-circuit сразу, возвращает '' (не оценивает 1 и []).
  Результат: '' (string).
```
console.log('' && 1 && []);  // ''
// Если все truthy: true && [] && 'hi' → 'hi' (последний)
// Guard: '' && doExpensive() → не вызовет doExpensive()
```
Собеседник отметил "как false" — верно, '' falsy, но возвращает именно '', не false. Если need bool: !!(expr).

Ключевые отличия, pitfalls и лучшие практики:

Short-circuit benefits: Экономит compute (e.g., && в if без else), предотвращает errors (null && method()). В functions: validate() && proceed(); — safe.
Truthy/falsy pitfalls: []/{} truthy (empty, но truthy — исторически); 0/false/'' falsy, но valid (e.g., || 'default' сломает count: 0). Решение: ?? для nullish, или explicit: if (arr && arr.length > 0).
Perf и side-effects: В hot loops — short-circuit faster (no eval rest). Но debug: console.log в right operand — может не сработать. В async: await promise && handle(); — но better try/catch.
Equality и coercion: '' || 1 === 1 true, но тип number. Для bool: Boolean(expr). В comparisons: a || b === c — check types.
В apps: React: {user && <Profile />} (JSX guard). Node API: req.body?.data ?? {}. TS: Улучшает с type narrowing (if (user) { user.prop } — non-null).
Testing: Jest: expect('' || 1).toBe(1);. Edge: NaN || [] → [] (NaN falsy). Circular? Не влияет, linear eval.
Modern alternatives: Для complex — destructuring defaults: const { name = 'Anon' } = user || {}. Или libraries (Ramda: R.or, R.and).

Логические операторы — основа conditional logic в JS, с short-circuit как superpower для concise, efficient code. В large-scale (microservices, SPAs) — они снижают boilerplate, но всегда validate assumptions (e.g., lint с eslint-plugin-no-unneeded-ternary). Понимание возвращаемых значений (не bool) предотвращает subtle bugs, делая код robust и performant.

Вопрос 9. Для чего нужны функции в JavaScript, какие типы функций бывают, чем отличаются классические от стрелочных и почему в React для колбэков используют стрелочные?

Таймкод: 00:08:19

Ответ собеседника: правильный. Для компоновки кода, переиспользования и выполнения действий; типы - классические и стрелочные; отличаются синтаксисом, контекстом (стрелочные наследуют от места создания), и возможностью new для классических; в React стрелочные для правильного наследования контекста.

Правильный ответ:
В JavaScript функции — это first-class citizens: они объекты (типа Function), которые можно присваивать переменным, передавать как аргументы, возвращать из других функций и использовать в композициях. Они служат для абстракции логики (инкапсуляция повторяющихся действий), переиспользования кода (DRY принцип), модульности (разделение concerns в apps), обработки событий (callbacks, event handlers) и функционального программирования (higher-order functions как map/filter). Функции позволяют создавать closures (замыкания для приватности данных), generators для итераторов (lazy evaluation) и async patterns (Promises/async-await). В production это критично для scalability: функции — building blocks для middleware (Express), reducers (Redux), hooks (React) или utils libs. Без них код становится procedural и hard-to-maintain; с ними — declarative и testable (pure functions без side-effects). JS функции — callable objects с [[Call]] internal slot, наследующими от Function.prototype, что даёт методы вроде .call(), .apply(), .bind().

Типы функций в JavaScript:
Функции классифицируются по синтаксису, поведению и контексту. Основные:

Function declarations (объявления): Hoisted (доступны до выполнения), named (имя для recursion/debug).
```
function greet(name) {  // Hoisted: можно вызвать до объявления
    return `Hello, ${name}`;
}
console.log(greet('World'));  // Работает даже выше
```
Полезны для global scope или utils, но pollute namespace — в modules prefer expressions.
Function expressions (анонимные/названные): Не hoisted (только var/let hoisting, но вызов до — ReferenceError). Могут быть anonymous (для callbacks) или named (для recursion).
```
const add = function(x, y) {  // Named expression
    return x + y;
};
// Anonymous в IIFE (Immediately Invoked)
(function() { console.log('IIFE: self-exec'); })();  // Выполнится сразу, приватный scope
```
Идеальны для modules (const fn = ...), event handlers или higher-order (Array.prototype.map(fn)).
Arrow functions (стрелочные, ES6+): Shorthand syntax, lexical this/arguments, no own this/super.
```
const multiply = (a, b) => a * b;  // Concise, implicit return
const log = () => { console.log('No args'); };  // Block body
```
Для short callbacks (map, setTimeout), но не для constructors (no new).
Другие specialized типы:
- *Generators (function)**: Yield values lazily, для iterables (e.g., infinite sequences).
```
function* idGenerator() {
    let id = 0;
    while (true) yield id++;
}
const gen = idGenerator();
console.log(gen.next().value);  // 0
```
  Полезны в streams (Node readable) или React Suspense.
- Async functions (async/await): Syntactic sugar над Promises, для async code.
```
async function fetchData(url) {
    const response = await fetch(url);
    return response.json();
}
```
  Standard для API calls, error handling с try/catch.
- Constructor functions: С new, для OOP (pre-class).
```
function Person(name) { this.name = name; }
const p = new Person('Alice');  // Instance
```
- Method shorthand (ES6): В objects/classes — greet() {} без function.
- Bound functions: .bind() возвращает new function с fixed this/args.

В практике: Declarations для core logic, expressions/arrows для modularity. Для perf — avoid nested functions в hot paths (closure overhead).

Отличия классических функций (declarations/expressions) от стрелочных:
Классические (regular) функции — полноценные callable objects с динамическим this (зависит от вызова: global в standalone, obj в methods, undefined в strict). Стрелочные — syntactic sugar, не имеют own this (lexical: наследуют от enclosing scope), super, arguments; всегда anonymous (no name unless assigned). Ключевые различия:

Синтаксис: Regular: function name(params) { body }. Arrow: (params) => expr (implicit return) или { body } (explicit). Arrows concise для 1-liners, но verbose для multi-line.

this binding: Regular — dynamic (this = caller context; undefined в non-method calls strict mode). Arrow — lexical (this = this родителя; fixed at creation). Это решает classic pitfalls (lost this в callbacks).
Пример проблемы с regular:

const obj = {
    name: 'Global',
    regular: function() {
        console.log(this.name);  // 'Global' в standalone
    },
    arrow: () => {
        console.log(this.name);  // this = global (lexical), 'undefined' в modules
    }
};
obj.regular();  // this = obj? Нет, если assign: const fn = obj.regular; fn(); → global

Решение для regular: .bind(this), .call(this, args), или let self = this (old-school). Arrow fixes:

const obj2 = {
    name: 'Obj',
    method: function() {
        setTimeout(() => {  // Arrow: this = method's this = obj2
            console.log(this.name);  // 'Obj'
        }, 1000);
    }
};
obj2.method();  // Работает без bind

arguments object: Regular имеют arguments (array-like с all args). Arrow — no, используйте rest params (...args).

function regular() { console.log(arguments[0]); }  // Works
const arrow = () => { console.log(arguments); };  // ReferenceError: no arguments
// Arrow: const arrow2 = (...args) => args[0];

new и constructors: Regular можно использовать с new (this = new instance, prototype setup). Arrow — SyntaxError с new (no [[Construct]]).
```
function Regular() { this.val = 42; }
new Regular();  // Ok, instance
const Arrow = () => { this.val = 42; };
new Arrow();  // TypeError
```
Hoisting и name: Declarations hoisted fully; expressions — var hoisted as undefined. Arrows — no hoisting, always expressions. Named arrows rare (const fn = name => ...).
Return и super: Arrows implicit return для single expr (no {}); no super (for classes).
Perf/Use cases: Arrows slightly faster (no prototype), но regular flexible. В V8 — both optimized.

Общий: Regular для OOP/constructors/methods; arrows для pure functions, callbacks (no this needed).

Почему в React для колбэков используют стрелочные?
В React (class components) колбэки (event handlers, lifecycle methods) часто теряют this (component instance) из-за lexical scoping: при передаче в props/DOM (e.g., onClick={this.handleClick}), this в callback = undefined/global (не component). Стрелочные фиксируют lexical this = enclosing (class method или render), сохраняя bind к component без explicit .bind(this) в constructor (perf hit: создаёт new function per render). Это предотвращает re-binds, снижает GC pressure и упрощает код. В hooks (functional components) arrows natural (no this, closures via useCallback).
Пример проблемы в class component:

class MyComponent extends React.Component {
    constructor(props) {
        super(props);
        this.state = { count: 0 };
        this.handleClick = this.handleClick.bind(this);  // Boilerplate, perf cost
    }
    handleClick() {
        this.setState({ count: this.state.count + 1 });  // Без bind: this undefined → error
    }
    render() {
        return <button onClick={this.handleClick}>Click</button>;  // this lost
    }
}

С arrow (inline или property initializer):

class MyComponent extends React.Component {
    constructor(props) {
        super(props);
        this.state = { count: 0 };
    }
    handleClick = () => {  // Arrow: lexical this = component
        this.setState({ count: this.state.count + 1 });  // Works
    }
    render() {
        return <button onClick={this.handleClick}>Click</button>;  // No bind needed
    }
}

Inline arrow в render: onClick={() => this.handleClick()} — но recreates function per render (perf issue; use useCallback в functional). В functional React (preferred):

const MyComponent = ({ }) => {
    const [count, setCount] = useState(0);
    const handleClick = useCallback(() => {  // Arrow + memo для perf
        setCount(c => c + 1);
    }, []);
    return <button onClick={handleClick}>Click</button>;
};

Преимущества в React: Consistent this, no constructor binds (faster init), easier refactoring to hooks. Pitfalls: Arrow methods не hoisted в class (use property initializers). В large apps (e.g., 100+ components) — экономит memory (no bound funcs). ESLint rule: prefer-arrow-callback. Для non-React: Arrows в array methods (map.filter), setInterval (preserve this).

Функции — сердце JS expressiveness, с arrows как evolution для modern patterns. В full-stack (Node/React) — комбинируйте с modules (export default fn), testing (jest.fn() mocks) и profiling (Chrome CPU) для optimized, bug-free code.

Вопрос 10. Что вы знаете о промисах и используете ли их?

Таймкод: 00:10:02

Ответ собеседника: неполный. Использую для асинхронного программирования, чтобы управлять асинхронностью; у них есть then и catch.

Правильный ответ:
Промисы (Promises) в JavaScript — это стандартный механизм (ES6+) для работы с асинхронными операциями, представляющий собой объект, который encapsuliрует результат (успех или неудачу) eventual асинхронного процесса. Они решают проблему "callback hell" (глубокая вложенность колбэков), позволяя chaining (цепочкам) и declarative handling async flow. Промис имеет три состояния: pending (ожидание), fulfilled (resolved — успешно завершён с value), rejected (ошибка с reason). Состояние immutable: после resolved/rejected не меняется, что обеспечивает predictability и thread-safety в single-threaded JS. Я активно использую промисы в production-коде (Node.js APIs, browser apps), особенно для I/O (fetch, file ops), timers или third-party libs, но часто комбинирую с async/await для readability (syntactic sugar над промисами). В legacy code или polyfill-сценариях (old browsers) — native или libs вроде bluebird. Промисы — основа modern async: без них код становится procedural и error-prone; с ними — composable, testable (mock resolved promises) и scalable (e.g., в microservices с Promise.all для parallel requests).

Структура и создание промисов:
Промис создаётся через конструктор new Promise(executor), где executor — функция с resolve/reject callbacks. Resolve(value) — fulfill, reject(reason) — error (обычно Error instance). Value/reason могут быть any (но prefer primitives/objects, avoid promises в value — flat chaining).
Пример базового создания:

const myPromise = new Promise((resolve, reject) => {
    setTimeout(() => {
        const success = Math.random() > 0.5;  // Simulate async
        if (success) {
            resolve('Operation succeeded!');  // Fulfilled с string
        } else {
            reject(new Error('Failed after timeout'));  // Rejected с Error
        }
    }, 1000);
});

Executor выполняется immediately (synchronously), так что side-effects (e.g., DB connect) happen at creation — careful с heavy ops. В практике: Wrap callbacks в промисы (promisify) для legacy APIs (e.g., fs.readFile в Node).

Методы и chaining:
Промисы immutable, но методы возвращают new promises для chaining. Это позволяет sequence async ops linearly, с error bubbling (rejections propagate до catch).

then(onFulfilled, onRejected): Returns promise, resolved с результатом onFulfilled(value) или onRejected(reason). OnFulfilled/onRejected optional; если omit — identity function (pass-through).
catch(onRejected): Shorthand для then(null, onRejected) — error handling.
finally(onFinally): Always runs (resolved/rejected), не влияет на value/reason; для cleanup (e.g., hide loader).

Пример chaining с error handling:

myPromise
    .then(result => {
        console.log(result);  // 'Operation succeeded!'
        return result.toUpperCase();  // Chain: return value для next then
    })
    .then(upper => {
        console.log(upper);  // 'OPERATION SUCCEEDED!'
        return fetch(`/api/${upper}`);  // Async chain (fetch returns promise)
    })
    .then(response => response.json())
    .catch(error => {
        console.error('Handled error:', error.message);  // 'Failed after timeout'
        return 'Fallback value';  // Recover: resolve с fallback
    })
    .finally(() => {
        console.log('Cleanup: async op done');  // Always runs
    });

Chaining flat, не nested — key advantage над callbacks. Если no catch — unhandled rejection (console.warn в Node, possible crash в old browsers; use process.on('unhandledRejection')).

Static методы для композиции:
Промисы composable: комбинируйте multiple для parallel/conditional async.

Promise.resolve(value): Immediate fulfilled promise (для testing или wrapping sync).
Promise.reject(reason): Immediate rejected.
Promise.all(iterable): Resolves когда все input promises fulfilled (value: array results в order); rejects на first rejection (fast-fail). Для parallel (e.g., multi-API calls).
Promise.allSettled(iterable, ES2020): Resolves всегда, value: array {status: 'fulfilled'/'rejected', value/reason} — non-fast-fail, полезно для robust logging.
Promise.race(iterable): Resolves/rejects на first settled (e.g., timeout vs. request).
Promise.any(iterable, ES2021): Resolves на first fulfilled (ignores rejections до last); rejects AggregateError если all rejected.

Пример Promise.all для parallel fetches:

const urls = ['/api/users', '/api/posts'];
const promises = urls.map(url => fetch(url).then(res => res.json()));
Promise.all(promises)
    .then(([users, posts]) => {
        console.log('All data:', { users, posts });  // Destructured
    })
    .catch(error => {
        console.error('One failed:', error);  // Если любой reject — здесь
    });
// AllSettled alternative:
Promise.allSettled(promises)
    .then(results => {
        results.forEach((r, i) => {
            if (r.status === 'rejected') {
                console.error(`URL ${i} failed:`, r.reason);
            }
        });
    });

Perf: All/race O(n) но parallel (non-blocking). В Node: Используйте для cluster ops или DB queries.

Использование в практике и отличия от других подходов:
Да, использую ежедневно: В React для data fetching (useEffect + fetch → then/setState), Node Express для async routes (middleware с promises), или WebSockets (wrap events). Prefer async/await над raw then (readable, try/catch для errors), но then полезен для simple chains или libs (e.g., Axios returns promises).
Async/await example (over promises):

async function fetchData() {
    try {
        const result = await myPromise;
        const upper = await result.toUpperCase();  // Await chains
        const response = await fetch(`/api/${upper}`);
        return await response.json();
    } catch (error) {
        console.error('Async error:', error);
        return 'Fallback';
    } finally {
        console.log('Cleanup');
    }
}
fetchData().then(data => console.log(data));

Отличия от callbacks: Callbacks fire once (no chaining), prone to inversion of control; promises — controlled flow, error propagation. От observables (RxJS): Promises eager/single-value, observables lazy/multi-value/streams. Pitfalls: No cancel (use AbortController для fetch); swallowed errors если no catch (use global handlers).

Лучшие практики и edge cases:

Error handling: Always chain .catch или try/await; log rejections. В production: Sentry/Raven для monitoring.
Perf: Avoid unnecessary promises (sync → resolve); use all/race wisely (e.g., race с timeout: Promise.race([op, timeoutPromise])). В loops — Promise.all(map(fn)).
Testing: Jest: await expect(promise).resolves.toBe(value); или mockResolvedValue. Mock timers с jest.useFakeTimers для setTimeout.
Polyfills/Transpilation: Babel для old env; native в modern (Node 10+, browsers post-2015). Для concurrency: Promises single-threaded, но с Workers — postMessage structured-clone.
Common errors: Executor errors → immediate reject; then return promise → flattened (no nesting). Circular promises — avoid. В TS: Promise<T> generics для type safety (e.g., Promise<User>).

Промисы — cornerstone async JS, enabling reliable, composable code в distributed systems (API orchestration). В full-stack: На фронте — fetch; на бэке (Node) — integrate с Go gRPC via promises. Их использование снижает boilerplate, повышая maintainability от prototypes до enterprise apps.

Вопрос 11. Какие состояния бывают у промиса, для чего используются then, catch и finally, в каких случаях finally выполняется, и какая альтернатива промисам?

Таймкод: 00:10:21

Ответ собеседника: неполный. Состояния: fulfilled (выполнен), pending (в процессе), rejected (отклонен); then для обработки успеха, catch для ошибок, finally выполняется всегда после then или catch; альтернатива - async/await с другим синтаксисом для асинхронности.

Правильный ответ:
Промисы в JavaScript определяют строгий lifecycle через состояния, которые обеспечивают предсказуемость асинхронных операций: они переходят из pending в fulfilled (resolved) или rejected, но никогда обратно или в промежуточные. Это предотвращает race conditions и упрощает error handling в distributed системах (e.g., API chains). Методы then, catch и finally — часть fluent API для обработки этих состояний, с short-circuit и propagation ошибок. Finally всегда выполняется после settled (fulfilled или rejected), независимо от исхода, что идеально для deterministic cleanup (e.g., resource release). Альтернативы промисам включают async/await (syntactic sugar), legacy callbacks, generators для iterables и observables (streams), но промисы — стандарт (Promise/A+ spec), интегрированный в fetch, Node fs.promises и т.д. В senior-практике я комбинирую then/catch для simple chains (perf-critical), async/await для readability в complex flows (e.g., ETL pipelines), и всегда добавляю global unhandled rejection handlers для robustness.

Состояния промиса:
Промис имеет ровно три возможных состояния, immutable после установки (no re-resolve/reject):

Pending (ожидание): Начальное состояние — операция в процессе (e.g., network request, computation). Executor в new Promise выполняется sync, но resolve/reject — async (microtask queue). Нет value/reason.
Fulfilled (resolved, успешно завершён): Переход из pending via resolve(value). Value — any (primitive, object, promise — flattened). Означает "операция succeeded", но value может быть falsy (e.g., resolve(0)).
Rejected (отклонён): Переход via reject(reason). Reason — обычно Error (для stack traces), но any. Означает "операция failed" (e.g., network error, validation).

Settled — общее для fulfilled/rejected (не pending). Проверить состояние: promise.status не public (internal), но inspect via then/catch (если catch fires — rejected). В dev: console.log(promise) shows Promise { <pending> } или { <fulfilled>: value }. Edge: resolve(reject promise) — flattened to rejected; reject(fulfilled) — to fulfilled (rare, avoid).

Пример демонстрации состояний:

const promise = new Promise((resolve, reject) => {
    console.log('Pending: executor started');  // Sync
    setTimeout(() => {
        if (Math.random() > 0.5) {
            resolve('Success value');  // → Fulfilled
        } else {
            reject(new Error('Failure reason'));  // → Rejected
        }
    }, 100);
    // Pending здесь
});

promise.then(value => console.log('Fulfilled:', value))
       .catch(reason => console.error('Rejected:', reason.message));

Использование then, catch и finally:
Эти методы возвращают new promises, enabling chaining и error bubbling (rejections propagate через then до catch). Они async (microtasks), так что log after promise может print до resolution.

then(onFulfilled, onRejected):
Основной метод для handling fulfilled (onFulfilled(value) — optional, default identity: return value). OnRejected — optional для local error handling (но prefer global catch). Возвращает promise, resolved с результатом callback (или error если thrown). Полезно для transformation (e.g., parse JSON) или sequencing. Если no onFulfilled — value pass-through.
Пример transformation:
```
fetch('/api/user')
    .then(response => {
        if (!response.ok) throw new Error('HTTP error');  // Manual reject
        return response.json();  // Fulfilled: transform to JSON
    })
    .then(user => user.name)  // Chain: extract name
    .then(name => console.log('User:', name));  // Final
```
Pitfall: Thrown в onFulfilled → rejection next promise.
catch(onRejected):
Shorthand: then(undefined, onRejected). Handles rejections (reason) от предыдущего promise или thrown errors. Возвращает promise, resolved с результатом onRejected (или propagated если thrown). Error bubbling: если no catch — rejection unhandled (trigger global event). Идеально для centralized errors (logging, retry).
Пример с recovery:
```
promise
    .then(value => {
        throw new Error('Simulated error in then');  // → Rejection
    })
    .catch(error => {
        console.error('Caught:', error.message);
        return 'Recovered value';  // Resolve next с fallback
    })
    .then(recovered => console.log(recovered));  // 'Recovered value'
```
Multiple catch в chain: Первый catches, но если re-throw — propagates.
finally(onFinally):
Выполняется всегда после settled (fulfilled или rejected), перед next then/catch. Не получает value/reason, не влияет на них (pass-through: resolved если previous fulfilled, rejected если rejected). Возвращает promise, mirroring previous outcome. Для cleanup: close connections, hide spinners, unsubscribe — гарантировано once, независимо от success/failure.
Пример:
```
let isLoading = true;
fetch('/api')
    .then(data => process(data))
    .catch(err => logError(err))
    .finally(() => {
        isLoading = false;  // Always: UI update, cleanup
        console.log('Request complete');
    });
// Если fulfilled: finally after then; rejected: after catch
```
Когда выполняется: Только после settled (не в pending). Если chain long — finally last в sequence. Edge: finally throw → new rejection, overriding previous (careful!); nested finally — sequential.

Альтернативы промисам:
Промисы — de-facto standard, но альтернативы для specific patterns:

Async/await (ES2017, sugar над промисами): Делает async code synchronous-like (await pauses execution до settled). Then/catch → implicit в try/catch. Readability++ для linear flows, но under hood — state machine (compiler transpiles to generators/promises). Не альтернатива, а enhancement: используйте для complex (e.g., loops с await), raw then для perf/simple.
Пример:
```
async function process() {
    try {
        const value = await promise;
        const json = await fetch('/api').then(r => r.json());
        return json;
    } catch (error) {
        console.error('Error:', error);  // Handles both reject и throw
        return null;
    } finally {
        cleanup();  // Always
    }
}
process().then(result => console.log(result));
```
Pitfalls: Await в loops — sequential (use Promise.all для parallel); no cancel (AbortController). Global: async IIFEs для top-level.
Callbacks (legacy, pre-ES6): Functions passed to async ops (e.g., fs.readFile(path, callback)). Error-first: callback(err, result). Prone to pyramid hell, no built-in chaining. Используйте для old libs (promisify via util.promisify в Node).
Пример:
```
fs.readFile('file.txt', (err, data) => {
    if (err) return handleError(err);
    process(data);
});
```
Альтернатива только в simple/single ops; migrate to promises.
Generators (function, ES6)**: Yield для pause/resume, co-routines like. С libs (co, run-async) — async flow, но verbose vs. async/await (transpiles to generators). Для iterables (e.g., async generators async function yield await). Rare standalone, но base для await.
Observables (RxJS, streams): Lazy, multi-value (vs. single-value promises), operators для streams (e.g., mergeMap для chaining). Для reactive apps (Angular, event streams). Promise-like: from(observable).toPromise(), но observables cancelable (unsubscribe).
Пример RxJS:
```
import { from } from 'rxjs';
from(fetch('/api')).subscribe({
    next: data => console.log(data),
    error: err => console.error(err),
    complete: () => cleanup()
});
```
В high-throughput (websockets, logs) — prefer over promises.

Лучшие практики:

Chaining strategy: Then для success paths, catch для errors (one per chain), finally для cleanup. Avoid .then().catch() nesting — linear chain.
Error propagation: Let rejections bubble; catch only где handle (retry, log). Global: window.addEventListener('unhandledrejection', e => { e.preventDefault(); log(e.reason); }); в Node — process.on.
Perf/Testing: Then microtasks (faster than macrotasks); в tests — await promise, expect.rejects/resolves. Для parallel — all/allSettled. AbortController для cancel (signal в fetch).
TS integration: Promise<T> для types (e.g., Promise<User[]>). Lint: no-floating-promises.

Эти элементы делают промисы robust для async ecosystems, с async/await как go-to для modern codebases. В full-stack: Promises в JS bridge с Go channels via JSON/HTTP, ensuring reliable async без callback pitfalls.

Вопрос 12. Сталкивались ли вы с библиотекой Axios и для чего она?

Таймкод: 00:12:29

Ответ собеседника: правильный. Да, для отправки HTTP-запросов.

Правильный ответ:
Да, я активно сталкивался с Axios и использовал её в многочисленных проектах как на фронтенде (React/Vue apps), так и на бэкенде (Node.js сервисы для proxying или testing APIs). Axios — это promise-based HTTP client library для JavaScript (и TypeScript), вдохновлённая jQuery.ajax, но modern и lightweight (около 20KB minified). Она предназначена для упрощения отправки HTTP-запросов (GET, POST, PUT, DELETE и т.д.), обработки ответов, управления ошибками и конфигурацией (headers, timeouts, interceptors). В отличие от native fetch (ES6+), Axios предоставляет более удобный API с automatic JSON parsing, broader browser support (polyfills XMLHttpRequest под капотом), и встроенными фичами вроде cancelable requests и request/response transformers. Это делает её идеальной для API integrations в SPA (single-page apps), где нужно handle auth tokens, retries или logging без boilerplate. В production я предпочитаю Axios для complex scenarios (e.g., file uploads, CORS handling), но для simple cases (modern browsers) — native fetch для меньшего bundle size. Axios — open-source (MIT license), maintained на GitHub (over 100k stars), и интегрируется seamlessly с промисами/async-await, React Query/SWR для caching, или Redux Toolkit Query для stateful API management.

Основные возможности и преимущества Axios:
Axios абстрагирует low-level детали HTTP, возвращая promises для async handling, что упрощает chaining (then/catch) или await. Ключевые фичи:

Автоматическая сериализация: JSON.stringify для POST/PUT bodies, FormData для multipart (files).
Response handling: Авто-парсинг JSON (response.data), status codes, headers.
Error handling: AxiosError с isAxiosError, response (если server error), или request (network).
Interceptors: Global hooks для modify requests/responses (e.g., add auth token to all headers).
Cancelation: AbortController-like via CancelToken (legacy) или native AbortSignal (v1+).
Config options: BaseURL, timeouts, params serialization (e.g., arrays as ?ids[]=1&ids[]=2), proxies.
Browser/Node compatibility: Works в browsers (no CORS issues via config) и Node (http/https adapters).

Преимущества над fetch: Fetch не reject на HTTP errors (4xx/5xx — resolved, check manual), нет auto-JSON, verbose для uploads. Axios — drop-in replacement для $.ajax в jQuery-free codebases. Минусы: Bundle size (если не нужен — tree-shake), но в modern bundlers (Webpack/Vite) — minimal. В perf-critical apps benchmark: Axios ~10-20% overhead vs. fetch, но convenience outweighs.

Базовый пример GET-запроса с промисами:

import axios from 'axios';

// Simple GET
axios.get('/api/users')
    .then(response => {
        console.log(response.data);  // Авто-JSON: array of users
        console.log(response.status);  // 200
        console.log(response.headers);  // Object с headers
    })
    .catch(error => {
        if (error.response) {
            // Server error (4xx/5xx)
            console.error('Status:', error.response.status);
            console.error('Data:', error.response.data);
        } else if (error.request) {
            // Network error (no response)
            console.error('Network error:', error.message);
        } else {
            // Other
            console.error('Error:', error.message);
        }
    });

Здесь catch handles все (network, server, timeout), с granular checks via AxiosError props.

Async/await версия (preferred для readability):

async function fetchUsers() {
    try {
        const { data, status } = await axios.get('/api/users');
        console.log('Users:', data);  // Destructured response
        if (status !== 200) throw new Error('Unexpected status');
        return data;
    } catch (error) {
        if (axios.isAxiosError(error)) {
            console.error('API Error:', error.response?.data || error.message);
        } else {
            console.error('Unexpected:', error);
        }
        return [];  // Fallback
    }
}
fetchUsers();

Destructuring { data } — shorthand для response.data, common в hooks (useEffect).

POST/PUT с данными и config:

// POST JSON
axios.post('/api/users', { name: 'Alice', age: 30 }, {
    headers: { 'Authorization': `Bearer ${token}` },  // Custom headers
    timeout: 5000,  // 5s timeout
    params: { filter: 'active' }  // Query params: /api/users?filter=active
})
.then(({ data }) => console.log('Created:', data))
.catch(error => console.error('Create failed:', error.response?.status));

// File upload (multipart)
const formData = new FormData();
formData.append('file', fileInput.files[0]);
axios.post('/api/upload', formData, {
    headers: { 'Content-Type': 'multipart/form-data' }  // Auto-set, но explicit ok
});

Params serialize arrays nicely (e.g., { ids: [1,2] } → ?ids=1&ids=2). Для auth: Interceptors auto-add tokens.

Interceptors для global logic (e.g., auth, logging):
Interceptors — powerful для cross-cutting concerns (AOP-like). Request interceptor fires перед send, response — после.

// Request interceptor: Add token
axios.interceptors.request.use(config => {
    const token = localStorage.getItem('token');
    if (token) {
        config.headers.Authorization = `Bearer ${token}`;
    }
    console.log('Request:', config.method, config.url);  // Logging
    return config;
}, error => Promise.reject(error));

// Response interceptor: Handle 401, transform data
axios.interceptors.response.use(
    response => {
        // Global transform: e.g., response.data = camelCase(response.data)
        return response;
    },
    error => {
        if (error.response?.status === 401) {
            // Logout/redirect
            localStorage.removeItem('token');
            window.location.href = '/login';
        }
        return Promise.reject(error);  // Propagate
    }
);

// Eject если need: const id = axios.interceptors.request.use(...); axios.interceptors.request.eject(id);

В large apps (multi-API) — interceptors centralize auth/logging, reducing duplication. Для retries: Custom interceptor с exponential backoff (e.g., retry on 5xx).

Cancel requests (avoid leaks):
В v0.22+ используйте AbortSignal (native).

const controller = new AbortController();
const signal = controller.signal;

axios.get('/api/long', { signal })
    .then(data => console.log(data))
    .catch(err => {
        if (err.code === 'ERR_CANCELED') {
            console.log('Canceled');
        }
    });

// Cancel on unmount (React useEffect)
useEffect(() => {
    const source = axios.CancelToken.source();  // Legacy, но works
    axios.get('/api', { cancelToken: source.token })
         .then(handleData);
    return () => source.cancel('Unmount');  // Cleanup
}, []);

Critical для tabs switching или search-as-you-type (cancel previous).

Интеграция с React/Node и best practices:

React: В custom hooks (useAxios) или libraries (react-query с axios adapter). useEffect: axios.get → setState. Для SSR (Next.js) — config baseURL.
Пример hook:

import { useState, useEffect } from 'react';
function useUsers() {
    const [users, setUsers] = useState([]);
    const [loading, setLoading] = useState(true);
    useEffect(() => {
        axios.get('/api/users')
             .then(({ data }) => setUsers(data))
             .catch(console.error)
             .finally(() => setLoading(false));
    }, []);
    return { users, loading };
}

Node.js: Для server-side requests (e.g., proxy to external APIs). Config: axios.create({ baseURL: 'https://api.external.com' }).
Security/Perf: Validate inputs (no XXS in URLs), use HTTPS, handle CORS (proxy в dev). Bundle: Import specific (import { get } from 'axios') для tree-shaking. Rate limiting: Custom interceptor с queues. Testing: Mock с axios-mock-adapter (jest):
```
import MockAdapter from 'axios-mock-adapter';
const mock = new MockAdapter(axios);
mock.onGet('/api/users').reply(200, [{ id: 1 }]);
```
Pitfalls: Default timeout none (set always), JSON only (для XML — manual), no streaming (для large files — native). Versions: v1.x для modern, v0 для legacy. Alternatives: Ky (lightweight fetch wrapper), Got (Node-only), или native fetch/cURL в Go interop.

В full-stack: Axios на фронте calls Go backend (JSON APIs), с shared schemas (OpenAPI/Swagger). Её использование ускоряет dev (less boilerplate), но в micro-optimizations — switch to fetch. В enterprise — Axios + interceptors = robust API layer, scalable от prototypes до high-traffic services.

Вопрос 13. Чем отличаются GET и POST запросы с точки зрения фронтенд-разработки?

Таймкод: 00:12:40

Ответ собеседника: правильный. GET для получения данных, параметры через query string; POST для отправки данных в теле запроса, не рекомендуется передавать тело в GET.

Правильный ответ:
В фронтенд-разработке GET и POST — два фундаментальных HTTP-метода (из семантики REST), определяющих, как клиент (браузер/JS) взаимодействует с сервером (e.g., Go API). GET предназначен для безопасного (safe) и идемпотентного (повтор вызова не меняет состояние) получения ресурсов, в то время как POST — для создания/изменения ресурсов, где запрос мутирует backend (non-idempotent). Это разделение критично для UX (e.g., GET для loading data без side-effects, POST для forms/submits), SEO (GET URLs bookmarkable), и безопасности (POST не кэшируется, скрывает payload). В JS (fetch/Axios) отличия влияют на config (method, body, headers), error handling и compliance с CORS/CSRF. На senior-уровне важно учитывать browser behaviors (GET в URL bar, POST via forms), caching (ETag/If-None-Match для GET), и edge cases (query length limits ~2k chars, POST для large payloads). В modern apps (React/Vue) — используйте GET для queries (data fetching), POST для mutations (create/update), интегрируя с libs вроде Axios для auto-config или TanStack Query для optimistic updates. Неправильное использование (e.g., GET с body — non-standard, ignored в многих servers) приводит к bugs, security holes (CSRF в GET) или perf issues (uncached POST).

Основные отличия с точки зрения фронтенда:

Назначение и семантика (safety и idempotency):
- GET: Safe (не меняет серверное состояние, только retrieves). Idempotent (множественные вызовы дают тот же результат, e.g., fetch user profile). Идеально для read-only ops: search, pagination, API endpoints вроде /users?id=123. В UX: Можно retry без риска (e.g., network flake), bookmark/share URLs (e.g., /search?q=term).
- POST: Non-safe и non-idempotent (создаёт/обновляет ресурсы, e.g., submit form → new user). Повтор может дублировать (e.g., double-submit order). Для mutations: login, create record, file upload. В UX: Подтверждение перед retry (e.g., "Resend?"), no bookmarking (state-changing).
  Важно: HTTP spec (RFC 7231) рекомендует GET без body (хотя tech possible, но ignored в Apache/Nginx; не используйте — confuses proxies). POST всегда с body для payload.

Передача параметров:

GET: Параметры в query string (URL: /api/users?name=Alice&age=30). Visible в address bar, logs, history. Encoding: URL-encoded (encodeURIComponent в JS). Limits: Browser ~2048 chars (IE ~2k, Chrome ~64k), no binary/large data.
POST: Параметры в request body (application/x-www-form-urlencoded, JSON, multipart/form-data). Hidden от user, unlimited size (server limits, e.g., 2MB в Nginx). Encoding: Auto в Axios (JSON.stringify для {data}), manual в fetch.
Пример в Axios (JS):

// GET: Query params
axios.get('/api/users', {
    params: { name: 'Alice', age: 30 }  // Auto → /api/users?name=Alice&age=30
})
.then(({ data }) => console.log(data));  // Response data: users array

// POST: Body payload
axios.post('/api/users', {
    name: 'Bob',
    age: 25,
    email: 'bob@example.com'  // JSON body: {"name":"Bob",...}
}, {
    headers: { 'Content-Type': 'application/json' }  // Default в Axios
})
.then(({ data }) => console.log('Created:', data.id));  // e.g., {id: 123}

В fetch (native):

// GET
fetch('/api/users?name=Alice', { method: 'GET' })
    .then(res => res.json())
    .then(data => console.log(data));

// POST
fetch('/api/users', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ name: 'Bob', age: 25 })  // Manual stringify
})
.then(res => res.json());

Для forms: GET — <form method="get"> (submits to URL), POST — <form method="post"> (body).

Кэширование, видимость и производительность:
- GET: Cachable (browsers/proxies store responses с Cache-Control/ETag; faster repeats). Visible (URL в history, shareable). Prefetchable (service workers, link rel="prefetch"). Perf: Smaller payloads, но query limits force pagination (e.g., ?page=1&limit=20).
- POST: Не кэшируется (state-changing, per RFC). Hidden (no URL exposure), но larger (body transfer). Perf: Slower для big data (e.g., images), но supports compression (gzip). В SPA: POST для auth (tokens in body, не URL для security).
  CORS impact: GET preflight optional (simple), POST often requires (custom headers/body), добавляя OPTIONS request.
Безопасность и ограничения:
- GET: Params exposed (avoid sensitive data: API keys, passwords — use headers или POST). CSRF low-risk (idempotent), но prefetch attacks possible. No body → no large attacks.
- POST: Safer для secrets (body encrypted в HTTPS). CSRF risk (tokens required, e.g., CSRFToken header). Supports auth (Basic in headers, JWT in body). Limits: Server-side (e.g., Go http.MaxBytesReader), browser (no strict, но memory).
  Pitfall: GET с sensitive queries — leaks в referrer (e.g., <a href="/api?token=secret">). Решение: POST для login, GET для public reads. В Go backend: Handle GET без body, POST с json.Unmarshal.

Когда использовать в фронтенде:

GET: Data fetching (lists, details, searches). REST: /resources/{id}. GraphQL: Single query в body (non-standard, но ok — overrides HTTP). Pagination/search: ?offset=0&query=term.
POST: Create ( /resources ), login ( /auth ), file uploads (multipart). Non-REST: Any mutation. В React: useMutation для POST, useQuery для GET (Apollo/TanStack).
Пример в React с Axios:

import { useState } from 'react';
import axios from 'axios';

function UserForm() {
    const [users, setUsers] = useState([]);
    const [formData, setFormData] = useState({ name: '', email: '' });

    const fetchUsers = async () => {
        try {
            const { data } = await axios.get('/api/users', { params: { active: true } });
            setUsers(data);
        } catch (error) {
            console.error('Fetch failed:', error.response?.status);
        }
    };

    const createUser = async (e) => {
        e.preventDefault();
        try {
            const { data } = await axios.post('/api/users', formData);
            setUsers(prev => [...prev, data]);  // Optimistic update
            setFormData({ name: '', email: '' });  // Reset
        } catch (error) {
            if (error.response?.status === 400) {
                alert('Validation error');
            }
        }
    };

    return (
        <div>
            <button onClick={fetchUsers}>Load Users (GET)</button>
            <ul>{users.map(u => <li key={u.id}>{u.name}</li>)}</ul>
            <form onSubmit={createUser}>
                <input value={formData.name} onChange={e => setFormData({...formData, name: e.target.value})} />
                <button type="submit">Create User (POST)</button>
            </form>
        </div>
    );
}

Здесь GET — read, POST — mutate с validation.

Лучшие практики и pitfalls в фронтенде:

Idempotency checks: GET — retry auto (fetch retries), POST — user confirm (navigator.sendBeacon для unload).
Headers: GET — Accept: application/json; POST — Content-Type + CSRF (e.g., X-CSRF-Token). Axios auto-sets.
Error handling: GET 404 — normal (no data), POST 4xx — client error (validation). Use status checks.
Perf/SEO: GET для SSR (Next.js prerender), POST для dynamic (noindex). Compress POST bodies.
Alternatives: PUT/PATCH для updates (partial vs full), DELETE для removes (idempotent like GET). GraphQL — POST always (body с query).
Testing: Jest + msw: mock GET / POST handlers. Edge: Long query → 414 URI Too Long (switch to POST). В mobile/PWA — GET для offline (IndexedDB cache).

В full-stack (JS + Go): GET maps to http.Get (query params via r.URL.Query()), POST to http.Post (body via json.NewDecoder). Соблюдение семантики обеспечивает scalable APIs, с GET для public/read-heavy, POST для secure/mutating ops. В large apps — standardize с OpenAPI для consistency.

Вопрос 14. Чем отличаются protected и public методы в контексте фронтенда?

Таймкод: 00:13:20

Ответ собеседника: неправильный. Подумал про HTTP-методы, но protected - для инкапсуляции в классах, доступ только внутри класса, public - доступен отовсюду.

Правильный ответ:
В контексте фронтенд-разработки (преимущественно JavaScript/TypeScript с фреймворками вроде React, Vue или Angular) понятия public и protected методов относятся к объектно-ориентированному программированию (OOP) в классах, где они управляют доступом (visibility) к методам и свойствам для инкапсуляции (encapsulation) — ключевого принципа OOP, предотвращающего unintended мутации и упрощающего maintenance в large-scale apps. Public методы доступны извне класса (для внешнего использования, e.g., API компонента), protected — ограничены классом и его наследниками (subclasses), но не внешним кодом, что позволяет internal logic без exposure. Однако JavaScript (до ES2022) не имеет строгого синтаксиса для protected (как в Java/C#), полагаясь на conventions (e.g., _method для "protected-like") или closures для privacy. В TypeScript (TS) — explicit modifiers (public/protected/private) для compile-time checks. В фронтенде это критично для component architecture: public методы — для props/events (user interaction), protected — для subclassing или internal helpers (e.g., в React class components). Неправильное использование приводит к tight coupling (hard refactoring), security leaks (exposed internals) или bugs в inheritance (overridden protected). В modern JS/TS senior-практика: Prefer composition over inheritance (protected less needed), use private fields (#private) для true encapsulation, и conventions для readability. В React/Vue — hooks/composition APIs минимизируют классы, но в Angular (TS classes) — modifiers essential.

Public методы:
Public — по умолчанию в JS (все instance methods/properties public без modifiers). Доступны отовсюду: внутри класса, наследниках и внешнем коде. Используются для exposed API: user-facing (e.g., render, event handlers), или public interfaces (e.g., component methods для refs). В фронтенде: Public методы компонентов — для lifecycle (mount), или utils (validateForm). Преимущества: Flexibility, но risk over-exposure (e.g., mutable state via public setter).

Пример в vanilla JS class:

class UserComponent {
    constructor(name) {
        this.name = name;  // Public property
    }

    // Public method: Доступен externally
    greet() {
        return `Hello, ${this.name}`;  // Использует public this.name
    }

    // Public setter (JS no strict, но convention)
    setName(newName) {
        this.name = newName;  // External мутация
    }
}

const user = new UserComponent('Alice');
console.log(user.greet());  // 'Hello, Alice' — external access
user.setName('Bob');  // External call, changes internal
console.log(user.greet());  // 'Hello, Bob'

Здесь greet/setName — public, callable via instance (user.greet()). В React class component:

class MyComponent extends React.Component {
    constructor(props) {
        super(props);
        this.state = { count: 0 };
    }

    // Public method: Доступен via ref (React.createRef().current.increment)
    increment() {
        this.setState({ count: this.state.count + 1 });
    }

    render() {
        return <button onClick={this.increment.bind(this)}>Count: {this.state.count}</button>;
    }
}

Public increment — для external triggers (parent components), но bind(this) needed (arrow alternative).

Protected методы:
В JS нет native protected (доступ только класс + subclasses). Convention: Prefix _method (underscore) сигнализирует "internal, do not call externally", enforced by docs/linters (ESLint: no-underscore-dangle). True privacy — closures или WeakMaps (manual). В ES2022+ — private #fields/#methods (class-only, no inheritance), но protected simulate via _ или TS. В фронтенде: Protected для shared logic в inheritance hierarchies (e.g., BaseComponent с _validate для subclasses), или internal helpers (e.g., _computeStyles в UI lib). Не expose, чтобы hide implementation details (e.g., caching logic). В TS — explicit protected: Compiler errors на external access, type-safe inheritance.

Пример в JS с convention (protected-like):

class BaseValidator {
    _validateEmail(email) {  // Protected convention: _ prefix
        return email.includes('@');
    }

    validateUser(user) {
        // Internal use of "protected"
        return this._validateEmail(user.email);
    }
}

class UserValidator extends BaseValidator {
    validate(user) {
        // Subclass access to "protected"
        if (!this._validateEmail(user.email)) {
            throw new Error('Invalid email');
        }
        return true;
    }
}

// External: Cannot/should not call _validateEmail
const validator = new UserValidator();
console.log(validator.validate({ email: 'test@example.com' }));  // true
// validator._validateEmail('bad') — works technically, but anti-pattern (lint error)

Здесь _validateEmail — "protected": Used internally/subclasses, но JS allows external (enforce via team rules/JSDoc @private). Для strict: Closures.

function createValidator() {
    function _validateEmail(email) {  // Truly protected via closure
        return email.includes('@');
    }

    return {
        validateUser(user) {  // Public
            return _validateEmail(user.email);
        }
    };
}

const validator = createValidator();
// validator._validateEmail — undefined, inaccessible

В TypeScript (common в Angular/React TS):

class BaseComponent {
    protected _internalMethod(): void {
        console.log('Protected: subclass only');
    }

    public publicMethod(): void {
        this._internalMethod();  // Ok inside class
    }
}

class SubComponent extends BaseComponent {
    validate() {
        this._internalMethod();  // Ok in subclass
    }
}

// External
const sub = new SubComponent();
sub.publicMethod();  // Ok
// sub._internalMethod();  // TS error: Protected member

TS enforces at compile-time, generates JS без runtime checks (convention-based).

Ключевые отличия и использование в фронтенде:

Доступ: Public — everywhere (instance.method()), protected — class/subclasses only (convention/TS). Public для API (props, events), protected для inheritance (shared internals без exposure).
Инкапсуляция: Protected hides details (change _method без breaking external), public contracts (stable API). В JS: No enforcement — rely on self-discipline/TS.
Inheritance: Protected accessible в subclasses (e.g., BaseUI._render → ChildUI overrides), public too, но protected signals "internal".
В React/Angular/Vue: React classes — все public (no modifiers), use _ для protected (e.g., _handleInternalClick). В functional React — no classes, privacy via modules/closures. Angular (TS) — protected common для directives/services (e.g., protected ngOnInit in base). Vue (options API) — methods public, use private plugins.
Perf/Security: Protected reduces attack surface (no external tampering internals), no runtime cost (JS). В large teams: JSDoc/TS для docs (e.g., /** @protected */).

Пример в React с protected convention:

class BaseButton extends React.Component {
    _handleClick(e) {  // Protected: Internal logic
        if (this.props.disabled) return;
        console.log('Internal click handled');
    }

    render() {
        return <button onClick={(e) => this._handleClick(e)}>{this.props.children}</button>;
    }
}

class CustomButton extends BaseButton {
    _handleClick(e) {  // Override protected
        super._handleClick(e);
        this.props.onCustomClick(e);
    }
}

// External: CustomButton public API via props, internals hidden

Лучшие практики: Avoid deep inheritance (favor composition: hooks/mixins), use private # для true privacy (ES2022+), TS для enterprise. В testing: Mock public, ignore protected (internal). Это обеспечивает modular, secure фронтенд-код, scalable от utils до component libraries. В full-stack (JS + Go): JS classes mirror Go structs/methods (public by default), но JS flexible для dynamic access.

В контексте разработки на Go алгоритмы — это фундамент для оптимизации производительности (e.g., в high-throughput системах вроде микросервисов или data processing), решения задач на LeetCode/HackerRank для интервью, и реализации core logic (e.g., routing, caching, search в API). Go подчёркивает эффективность (O(n) preferred для large datasets), с встроенными пакетами (sort, container/heap, math/rand) и generics (Go 1.18+) для reusable impl. Я знаю широкий спектр: от базовых (sorting/searching) до advanced (graphs, DP, strings), классифицируя по категориям. В практике senior-разработки фокусируюсь на trade-offs: time/space complexity (Big O), concurrency-safety (e.g., с sync.Mutex для shared data), и Go-idioms (slices/maps для collections). Для реальных задач комбинирую с SQL (e.g., indexing для search) или external libs (gonum для numerics). Ниже — ключевые алгоритмы с примерами, complexities и Go-кодом; это не exhaustive list, но core для backend (e.g., ETL, networking).

Сортировка (Sorting Algorithms):
Используются для упорядочивания данных (e.g., API responses, logs), с Go sort.Slice для stable O(n log n). Выбор зависит от data: quicksort для average-case fast, mergesort для stable.

QuickSort: Divide-and-conquer, pivot-based partitioning. Average O(n log n) time, O(log n) space; worst O(n²) (unbalanced, mitigate random pivot). In-place, unstable. Полезен для custom comparators в Go.
Go пример (manual impl для slice ints):

package main

import "fmt"

func quickSort(arr []int) {
    if len(arr) < 2 {
        return
    }
    pivot := arr[0]  // Simple pivot (randomize для prod)
    var left, right []int
    for i := 1; i < len(arr); i++ {
        if arr[i] <= pivot {
            left = append(left, arr[i])
        } else {
            right = append(right, arr[i])
        }
    }
    quickSort(left)
    quickSort(right)
    copy(arr, append(append(left, pivot), right...))  // Reconstruct
}

func main() {
    nums := []int{3, 6, 1, 8, 2, 4}
    quickSort(nums)
    fmt.Println(nums)  // [1 2 3 4 6 8]
}

В prod: sort.Slice(nums, func(i, j int) bool { return nums[i] < nums[j] }) — stable, optimized.

MergeSort: Divide, conquer, merge. O(n log n) time/space, stable. Идеален для linked lists или external sorting (large files). Go: Manual или sort.Sort для interfaces.
HeapSort: Build max-heap, extract roots. O(n log n) time/space, in-place, unstable. Полезен для priority queues (container/heap).

Поиск (Searching Algorithms):
Для efficient data retrieval (e.g., in maps/slices, DB queries). Go: Binary search в sorted data.

Binary Search: Halve search space. O(log n) time, requires sorted array. Для Go slices: sort.SearchInts или custom.
Go пример:

package main

import (
    "fmt"
    "sort"
)

func binarySearch(arr []int, target int) int {
    sort.Ints(arr)  // Ensure sorted
    idx := sort.SearchInts(arr, target)
    if idx < len(arr) && arr[idx] == target {
        return idx
    }
    return -1  // Not found
}

func main() {
    nums := []int{1, 3, 5, 7, 9}
    fmt.Println(binarySearch(nums, 5))  // 2 (index)
}

В SQL: INDEX на columns для O(log n) lookups (e.g., CREATE INDEX ON users(name)). Linear search O(n) для unsorted — fallback.

Breadth-First Search (BFS): Queue-based traversal для shortest path в unweighted graphs (e.g., social networks, level-order trees). O(V + E) time/space. Go: container/list для queue.

Графы (Graph Algorithms):
Ключ для networking (e.g., API routing, dependency graphs в microservices). Go: Adjacency lists (map[int][]int).

Depth-First Search (DFS): Stack/recursion для traversal (e.g., cycle detection). O(V + E) time. Рекурсия risk stack overflow — iterative с stack.
Go пример (DFS на graph):

package main

import "fmt"

func dfs(graph map[int][]int, start int, visited map[int]bool) {
    if visited[start] {
        return
    }
    visited[start] = true
    fmt.Printf("Visit %d\n", start)
    for _, neighbor := range graph[start] {
        dfs(graph, neighbor, visited)
    }
}

func main() {
    g := map[int][]int{0: {1, 2}, 1: {0, 3}, 2: {0}, 3: {1}}
    visited := make(map[int]bool)
    dfs(g, 0, visited)  // Visit 0,1,3,2 (order depends)
}

Dijkstra's Algorithm: Shortest path в weighted graphs (e.g., routing в services). O((V + E) log V) с priority queue (heap). Go: container/heap + map для distances. Для unweighted — BFS.
Topological Sort: Linear ordering для DAG (e.g., build dependencies). Kahn's (BFS indegree) или DFS. O(V + E).

Деревья (Tree Algorithms):
Для hierarchical data (e.g., JSON parsing, org charts). Go: Structs с pointers.

Binary Search Tree (BST) Operations: Insert/search/delete O(h) time (h=height, balanced O(log n)). Go: Custom node struct. Для balanced — AVL/Red-Black (external: gonum/graph).
Tree Traversal: In-order (sorted), pre/post-order (DFS), level-order (BFS). O(n) time. Рекурсия simple, но iterative для deep trees.

Динамическое программирование (DP):
Для optimization (e.g., caching computations в APIs). Memoization bottom-up/top-down.

Fibonacci: Classic memo. O(n) time/space vs. O(2^n) naive recursion. Go: map[int]int для memo.
Go пример (top-down memo):

package main

import "fmt"

func fib(n int, memo map[int]int) int {
    if n <= 1 {
        return n
    }
    if val, ok := memo[n]; ok {
        return val
    }
    memo[n] = fib(n-1, memo) + fib(n-2, memo)
    return memo[n]
}

func main() {
    memo := make(map[int]int)
    fmt.Println(fib(10, memo))  // 55
}

Bottom-up: Slice dp[n+1], dp[i] = dp[i-1] + dp[i-2]. Для knapsack (resource alloc, e.g., cache eviction) — 2D dp table.

Longest Common Subsequence (LCS): DP table для strings (e.g., diff tools). O(mn) time/space.

Строки и массивы (String/Array Algorithms):
Техники вроде two-pointers (для sorted arrays/strings), sliding window (subarrays).

Two Pointers: Для palindromes, two-sum. O(n) time. E.g., remove duplicates in sorted slice.
Go пример (two sum):

package main

import "fmt"

func twoSum(nums []int, target int) (int, int) {
    seen := make(map[int]int)
    for i, num := range nums {
        complement := target - num
        if j, ok := seen[complement]; ok {
            return j, i
        }
        seen[num] = i
    }
    return -1, -1  // Not found
}

func main() {
    nums := []int{2, 7, 11, 15}
    i, j := twoSum(nums, 9)
    fmt.Println(i, j)  // 0 1 (2+7=9)
}

Это hashmap variant O(n); pure two-pointers для sorted. Sliding window для max subarray sum.

KMP (Knuth-Morris-Pratt): String matching O(n + m). Для search in logs/text.

Другие (Hashing, Greedy, etc.):

Hashing: Maps для O(1) lookups (e.g., count frequencies). Go: map[T]V, sync.Map для concurrency.
Greedy: Interval scheduling (sort by end time). O(n log n). Для resource alloc.
Union-Find (Disjoint Set): Для connectivity (e.g., networks). O(α(n)) amortized с path compression.

В Go dev: Алгоритмы интегрирую с concurrency (e.g., goroutines для parallel sort chunks), testing (go test -bench для perf), и SQL (e.g., B-tree indexes mimic BST). Для interview: Объясняю complexities, optimize (e.g., in-place vs. extra space), и Go specifics (no generics pre-1.18 — interfaces). В production: Benchmark (testing.B), profile (pprof), и libs (sort, gonum) для non-core. Это toolkit для scalable, efficient code, от simple CRUD до ML pipelines.

Вопрос 15. Зачем нужен React для разработчика и пользователя, в чём его преимущества?

Таймкод: 00:15:13

Ответ собеседника: неполный. Ускоряет разработку компонентным подходом и JSX; для пользователя ускоряет загрузку и работу приложения.

Правильный ответ:
React — это declarative JavaScript-библиотека (не фреймворк, как Angular) для создания user interfaces (UI), разработанная Facebook в 2013 году и ставшая de-facto стандартом для frontend-разработки. Она фокусируется на component-based architecture, где UI разбивается на reusable, self-contained компоненты (e.g., Button, UserCard), что упрощает building complex apps вроде dashboards, e-commerce или admin panels. Для разработчика React ускоряет прототипирование, maintenance и scaling за счёт declarative syntax (описываешь "что" нужно, не "как" рендерить), virtual DOM для efficient updates и богатой экосистемы (hooks, Redux, React Router). Для пользователя — обеспечивает smooth, responsive experiences в single-page applications (SPA), минимизируя page reloads, с fast rendering и accessibility out-of-box. Преимущества React — в perf (reconciliation algorithm минимизирует DOM mutations), reusability (components как Lego), и community (миллионы пакетов в npm, tools вроде Create React App/Next.js). В production это снижает time-to-market (dev velocity) и улучшает UX (e.g., infinite scroll без lag). Минусы: Learning curve для hooks/state, bundle size (code-splitting помогает), но в senior-практике React — backbone для scalable apps (e.g., Netflix, Airbnb), интегрируемый с backend вроде Go APIs via JSON/REST. Alternatives (Vue — simpler, Svelte — compile-time) уступают в adoption, но React excels в enterprise из-за type-safety (с TypeScript) и SSR (server-side rendering для SEO).

Зачем React нужен разработчику:
React упрощает создание и управление UI, абстрагируя low-level DOM manipulations (add/remove/update elements). Вместо imperative code (jQuery-style: document.getElementById().innerHTML = ...) — declarative: JSX (syntax extension, transpiles to React.createElement) описывает UI как tree of components. Это ускоряет dev: Reusable components (e.g., <Button variant="primary">) снижают duplication, hooks (useState, useEffect) handle state/side-effects без classes (functional components preferred post-16.8). Ecosystem: State management (Zustand/Redux для global), routing (React Router), testing (React Testing Library/Jest), и tools (Vite для fast HMR). В large teams — component libraries (Material-UI, Ant Design) enforce consistency, props drilling решается Context/Redux. Для full-stack dev: React frontend consumes Go backend (fetch/Axios для /api/users), с shared types (TypeScript + Go structs). Преимущества: Hot reload (изменения visible instantly), composition (higher-order components/HOCs), и scalability (code-split с lazy/Suspense для big apps). Без React — vanilla JS или jQuery для simple sites, но для dynamic UIs (real-time dashboards) — overhead в manual DOM sync.

Пример simple component с hooks (functional, modern style):

import React, { useState, useEffect } from 'react';

function UserList({ apiUrl }) {  // Props: Reusable via params
    const [users, setUsers] = useState([]);  // Local state (hook)
    const [loading, setLoading] = useState(true);

    useEffect(() => {  // Side-effect: Fetch on mount/update
        fetch(apiUrl)  // Go backend: /api/users
            .then(res => res.json())
            .then(data => {
                setUsers(data);  // Update state → re-render
                setLoading(false);
            })
            .catch(err => console.error('Fetch error:', err));
    }, [apiUrl]);  // Dependency: Re-run if apiUrl changes

    if (loading) return <div>Loading...</div>;  // Conditional render

    return (
        <ul>
            {users.map(user => (  // JSX: Map to list (key for perf)
                <li key={user.id}>{user.name} - {user.email}</li>
            ))}
        </ul>
    );
}

// Usage: <UserList apiUrl="http://localhost:8080/api/users" />

Здесь useState — declarative state (no manual this.setState), useEffect — lifecycle (componentDidMount-like). Dev benefit: Predictable re-renders (only changed parts), easy testing (render(<UserList />, { apiUrl }) → expect(screen.getByText('Alice'))).

Зачем React нужен пользователю:
Пользователи получают seamless, app-like experiences: SPA без full page reloads (virtual DOM diffs changes, updates real DOM minimally), что ускоряет navigation (e.g., single-click transitions). Responsive UI: Animations (Framer Motion), offline support (Service Workers), и accessibility (ARIA via semantic JSX). Fast loading: Code-splitting (React.lazy) loads chunks on-demand, SSR (Next.js) prerenders для initial SEO/fast TTI (Time to Interactive). В mobile (React Native) — native perf без webviews. Преимущества: Reduced latency (client-side routing), personalization (dynamic content via state), и reliability (error boundaries catch crashes). Без React — traditional MPA (multi-page apps) с reloads (slow on mobile), или vanilla JS с choppy updates. В e-commerce: Cart updates instant (no refresh), search results live (debounced input).

Ключевые преимущества React:

Virtual DOM и Reconciliation: React builds in-memory tree (JSX → VDOM), diffs с previous (Fiber algorithm) на changes, batches DOM updates. O(1) для simple, efficient для complex (vs. full re-render). Perf win: 1000+ elements update без jank.
Как работает:
```
// Before render: VDOM = { type: 'div', children: [{ type: 'p', props: { children: 'Hello' } }] }
// Change state → New VDOM → Diff (keys, props) → Minimal mutations (e.g., textNode.nodeValue = 'Hi')
```
В Go backend: React consumes fast JSON (e.g., gorilla/mux для /api), no heavy HTML templates.
Компонентность и Reusability: UI как tree of components (composition: <App> <Header /> <UserList /> </App>). Props (input), state (internal), events (onClick). Scalable: Library of 100+ components (e.g., Form с validation).

Hooks и Functional Paradigm: Post-16.8 — functional components + hooks replace classes (no this pitfalls). Custom hooks (useFetch) — reusable logic.
Custom hook пример:

import { useState, useEffect } from 'react';

function useFetch(url) {
    const [data, setData] = useState(null);
    const [loading, setLoading] = useState(true);

    useEffect(() => {
        setLoading(true);
        fetch(url)
            .then(res => res.json())
            .then(setData)
            .finally(() => setLoading(false));
    }, [url]);

    return { data, loading };
}

// Usage: const { data, loading } = useFetch('/api/users');  // Reusable в любом component

Dev: Encapsulates fetch logic, testable independently.

Ecosystem и Tooling: 1M+ npm pkgs (e.g., React Query для caching/optimistic), DX tools (ESLint, Storybook для component docs), и SSR/SSG (Next.js для Go API integration). Community: Facebook maintenance, conferences (React Conf).
Perf и Scalability: Memoization (React.memo, useMemo), concurrent mode (18+ для non-blocking UI), и tree-shaking (Vite/Webpack). Handles 1M+ rows (virtualization с react-window). Для users: 60fps animations, PWA features.

Trade-offs и лучшие практики:

Learning: JSX/state curve, но docs excellent. Start с functional + hooks.
Bundle: ~40KB gzipped; optimize с code-split (dynamic imports).
State: Local (useState) для simple, global (Context/Zustand) для complex; avoid prop drilling.
Testing/SEO: RTL для black-box tests, Next.js для SSR (Go renders JSON, Next hydrates).
Vs. Others: React — library (flexible stack), Vue — progressive, Angular — full-framework (more boilerplate). React wins в jobs/community.

В full-stack: React + Go = Efficient (Go fast API, React dynamic UI). Для prep: Practice components/hooks, understand VDOM (key for perf interviews). React — accelerator для dev productivity и user satisfaction, enabling modern web apps без low-level hacks.

Вопрос 16. В чём именно ускорение разработки в React?

Таймкод: 00:15:57

Ответ собеседника: правильный. Компонентный подход, переиспользуемость компонентов, удобство JSX.

Правильный ответ:
Ускорение разработки в React достигается через paradigm shift от imperative (manual DOM manipulation в vanilla JS или jQuery) к declarative, component-centric модели, где фокус на "что" рендерить, а не "как" обновлять UI. Это снижает boilerplate (no manual event binding или state sync), повышает productivity на 2-3x (по метрикам Facebook/Google studies: faster prototyping, fewer bugs в state management), и облегчает collaboration в teams (components как modular units). Ключевые факторы: component reusability (Lego-like building), JSX для colocation (HTML/JS вместе, no context switching), hooks для logic extraction (reusable без HOCs/classes), и rich tooling (HMR — hot module replacement для instant feedback, ESLint/Prettier для consistency). В сравнении с vanilla JS (hours на simple form с events/state) — React minutes: <Form onSubmit={handleSubmit}>. Для backend dev (e.g., Go APIs) React ускоряет frontend integration: Consume JSON endpoints quickly via hooks, с shared schemas (TypeScript + Go structs). В production: Code reuse cuts maintenance (update one Button → all instances), и scalability (lazy loading components). Минусы minimal (initial setup), но senior-практика: Use functional components + hooks для 90% cases, custom hooks для DRY (Don't Repeat Yourself). Это не magic — algorithmic efficiency VDOM + composition patterns, enabling rapid iteration от MVP к enterprise apps (e.g., Instagram built on React).

Компонентный подход и переиспользуемость:
Core acceleration: UI как tree of independent components (functional или class), каждый с props (input), state (internal), и lifecycle (effects). Reusability: Build once, use everywhere (e.g., <Button> в 50+ places), composition (nesting: <App> <Header> <Nav /> </Header> </App>). Это снижает duplication (vanilla: Copy-paste HTML/JS), enforces DRY, и simplifies testing/refactoring (mock <Child /> independently). В large apps (100+ components) — design systems (Storybook для docs/catalog), slashing dev time на UI consistency.
Пример reusable component (Button с variants, props-driven):

import React from 'react';

function Button({ variant = 'primary', size = 'medium', onClick, children, disabled = false }) {
    const baseStyles = 'px-4 py-2 rounded font-semibold focus:outline-none transition-colors';
    const variants = {
        primary: 'bg-blue-500 hover:bg-blue-600 text-white',
        secondary: 'bg-gray-200 hover:bg-gray-300 text-gray-800'
    };
    const sizes = {
        small: 'text-sm px-2 py-1',
        medium: 'text-base px-4 py-2'
    };

    return (
        <button
            className={`${baseStyles} ${variants[variant]} ${sizes[size]}`}
            onClick={onClick}
            disabled={disabled}
            // Accessibility: ARIA props
            aria-disabled={disabled}
        >
            {children}
        </button>
    );
}

// Usage: Reusable в любом месте, no rewrite
function LoginForm() {
    const handleSubmit = (e) => {
        e.preventDefault();
        // Call Go API: fetch('/api/login', { method: 'POST', body: JSON.stringify(formData) })
    };

    return (
        <form onSubmit={handleSubmit}>
            <Button variant="primary" type="submit">Login</Button>
            <Button variant="secondary" onClick={handleCancel}>Cancel</Button>
        </form>
    );
}

Здесь Button — reusable (props configure look/behavior), dev time: Seconds на new form vs. minutes manual CSS/JS. Composition: <LoginForm> nests Button, scales to <Dashboard> <Sidebar> <Button> </Sidebar> </Dashboard>.

Удобство JSX и declarative rendering:
JSX — sugar над React.createElement, позволяющий write UI как HTML в JS (transpiles via Babel). Acceleration: Colocation (logic + markup together, no separate HTML files), no string concatenation (vanilla: innerHTML = '<div>' + name + '</div>'), и declarative diffs (React handles updates via state changes). Это cuts cognitive load: Focus on data flow (state → props → render), not imperative steps (addEventListener, querySelector). HMR в Vite/Create React App — edit component, see changes instantly (no full reload). Для Go dev: JSX consumes API data seamlessly (e.g., {users.map(u => <UserCard user={u} />)}), с type checks в TS.
Пример declarative list с state (vs. vanilla manual loops/DOM):

import React, { useState } from 'react';

function TodoList() {
    const [todos, setTodos] = useState([]);  // Declarative state
    const [input, setInput] = useState('');

    const addTodo = () => {
        if (input.trim()) {
            setTodos([...todos, { id: Date.now(), text: input, done: false }]);  // Immutable update → auto re-render
            setInput('');
        }
    };

    return (
        <div>
            <input
                value={input}
                onChange={(e) => setInput(e.target.value)}  // One-liner event
                placeholder="Add todo"
            />
            <button onClick={addTodo}>Add</button>
            <ul>
                {todos.map(todo => (  // JSX map: Declarative list gen
                    <li key={todo.id}>
                        <input
                            type="checkbox"
                            checked={todo.done}
                            onChange={() => setTodos(todos.map(t => t.id === todo.id ? { ...t, done: !t.done } : t))}
                        />
                        {todo.text}
                    </li>
                ))}
            </ul>
        </div>
    );
}

Dev time: ~10 lines для full interactive list (add/check), vs. vanilla 50+ (createElement, addEventListener, manual array ops/DOM insert). State change (setTodos) triggers targeted re-render (only <li> changes), no full page refresh.

Hooks для логики и переиспользования:
Hooks (useState, useEffect, custom) extract stateful logic из components, reusable via custom hooks. Acceleration: No class boilerplate (this binding, lifecycle methods), share logic (e.g., useAuth в 10 components). Custom hooks — functions, testable standalone. В teams: Hooks standardize patterns (e.g., data fetching), reducing bugs от shared code.
Custom hook для API (reusable fetch logic, integrates Go backend):

import { useState, useEffect } from 'react';

function useApi(url) {
    const [data, setData] = useState(null);
    const [loading, setLoading] = useState(true);
    const [error, setError] = useState(null);

    useEffect(() => {
        setLoading(true);
        setError(null);
        fetch(url)  // Go: http.HandleFunc("/api", handler)
            .then(res => {
                if (!res.ok) throw new Error(`HTTP ${res.status}`);
                return res.json();
            })
            .then(setData)
            .catch(err => setError(err.message))
            .finally(() => setLoading(false));
    }, [url]);

    return { data, loading, error, refetch: () => {/* Trigger again */} };
}

// Usage: <UserList data={useApi('/api/users').data} />

Hook reusable (useApi('/posts'), useApi('/users')), dev time: Write once, use everywhere — cuts 80% fetch boilerplate per component.

Tooling и ecosystem acceleration:

HMR/DevTools: Vite/Webpack HMR — edit props, see live (seconds vs. manual refresh). React DevTools — inspect state/props tree, time-travel debugging.
Ecosystem: npm libs (e.g., react-hook-form для forms — 5 lines vs. 50 manual), starters (Create React App). Integration: Axios/fetch для Go (e.g., json.NewEncoder для responses).
Metrics: Studies (State of JS) — React devs 30% faster prototyping; reusability reduces code 40-60% (e.g., shared <Modal> в app).

Лучшие практики для max acceleration:

Functional + Hooks: Avoid classes (verbose); custom hooks для patterns (auth, fetch).
Composition > Inheritance: Nest components, no deep hierarchies.
Optimization: useMemo/useCallback для perf (memoize expensive computes), но profile first (React Profiler).
Testing: RTL — test behaviors (fireEvent.click(button) → expect(screen.getByText('Added'))), fast iteration.
VS Vanilla: Simple todo — React 20min, vanilla 2hrs (events, state, DOM). Scale: 10x app — React maintainable, vanilla spaghetti.
With Go: React frontend + Go API — fast dev loop (go run → npm start), shared validation (e.g., Go structs → TS interfaces).

React ускоряет via modularity (components/hooks), expressiveness (JSX/declarative), и tools (HMR/ecosystem), shifting time от wiring к features. В prep: Build todo app — feel velocity firsthand. Для Go devs — bridge to full-stack efficiency.

Вопрос 17. Как JSX преобразуется в JavaScript и какие инструменты используются?

Таймкод: 00:16:15

Ответ собеседника: правильный. Через сборщик вроде Vite, который использует Babel как транспайлер.

Правильный ответ:
JSX (JavaScript XML) — это не часть спецификации ECMAScript, а расширение синтаксиса, позволяющее описывать UI-элементы в declarative стиле (как HTML внутри JS), что упрощает создание компонентов в React. Преобразование JSX в чистый JavaScript происходит на этапе transpilation (транспиляции) — статического анализа и генерации кода, который browsers и Node.js могут выполнить напрямую. Процесс включает парсинг JSX в абстрактное синтаксическое дерево (AST), трансформацию в вызовы функций (обычно React.createElement или jsx), и генерацию исполняемого JS. Это build-time операция (в dev/prod), обеспечивающая readability (JSX как "HTML") без runtime overhead (кроме VDOM reconciliation). В production transpiled JS минимизируется и бандлится, снижая размер (e.g., с tree-shaking). Для Go-разработчиков: JSX transpiles to JS, consuming Go APIs (fetch/json), с shared builds (e.g., esbuild для Go+JS wasm). Преимущества: Type-safe (TSX), colocation (logic+markup), но pitfalls — parse errors на invalid XML (e.g., unclosed tags). Senior-практика: Automatic runtime (React 17+) для smaller bundles, Vite/esbuild для sub-second builds, Babel для custom plugins (e.g., styled-jsx). Без transpilation JSX не работает (SyntaxError в browser), так что tools mandatory в pipelines.

Шаги преобразования JSX в JavaScript:

Парсинг (Parsing): JSX-код токенизируется и строится в AST (с помощью parser вроде @babel/parser или esbuild's internal). Tags (<div>) treated as expressions, attributes (className="foo") as props objects, children ({expr} или text) as array. Nested JSX — recursive AST nodes.
Трансформация (Transformation): AST walker (plugin/transpiler) заменяет JSX-nodes на function calls. Default: React.createElement(type, props, ...children) — создаёт VDOM object (virtual DOM tree). Props auto-normalized (e.g., class → className, onClick preserved). Expressions {name} inlined. Fragments <></> → React.Fragment.
Генерация кода (Code Generation): AST → stringified JS (generator). Output — plain ES5/ES6, executable. Additional: Polyfills (ES6 to ES5 для old browsers), minification (terser).
Runtime Execution: Transpiled JS runs, React reconciles VDOM to real DOM (diffing, patching). No JSX at runtime — only functions.

Пример преобразования (Babel classic runtime):

// JSX input (src/App.jsx)
import React from 'react';
function App({ name }) {
    return (
        <div className="container">
            <h1 onClick={() => alert('Hi')}>Hello {name}!</h1>
            <p>Count: {2 + 2}</p>
        </div>
    );
}

// Transpiled output (dist/App.js, simplified)
import React from 'react';
function App({ name }) {
    return React.createElement(
        'div',
        { className: 'container' },
        React.createElement(
            'h1',
            { onClick: () => alert('Hi') },
            'Hello ',
            name,
            '!'
        ),
        React.createElement(
            'p',
            null,
            'Count: ',
            4  // Expression {2 + 2} evaluated
        )
    );
}

Здесь <div> → createElement('div', props, children array). Children — mixed (strings, expr, nested elements). В automatic runtime (React 17+): jsx('div', { className: 'container', children: [jsx('h1', ...)] }) — no React import, smaller (~1KB less).

Инструменты для transpilation и интеграции:
Transpilation — не standalone; часть build pipeline (lint → transpile → bundle → serve). Tools vary by speed/features: Babel для flexibility, esbuild/SWC для perf. Bundlers orchestrate (e.g., Vite dev server transpiles on-the-fly).

Babel (babeljs.io) — основной transpiler:
Парсит/трансформирует AST, supports JSX via presets/plugins. @babel/preset-react — core (includes transform-react-jsx). Runtime: Classic (createElement) или automatic (jsx, React 17+). Config via .babelrc/babel.config.js. Slow для large projects (AST overhead), но extensible (plugins для emotion, graphql).
Установка/usage (CLI):
```
npm install --save-dev @babel/core @babel/cli @babel/preset-env @babel/preset-react
# .babelrc
{
  "presets": ["@babel/preset-env", ["@babel/preset-react", { "runtime": "automatic" }]]
}
npx babel src --out-dir dist --watch  # Transpile on change
```
Output: JS files в dist. В bundlers — loader (e.g., babel-loader).
esbuild (esbuild.github.io) — fast alternative:
Go-based bundler/transpiler, 10-100x faster Babel (parallel, no AST). Native JSX (no presets), outputs ESM/CJS. Limited plugins (no full Babel ecosystem), но sufficient для React. Vite/Next.js use internally.
CLI пример:
```
npm install --save-dev esbuild
npx esbuild src/index.jsx --bundle --outfile=dist/bundle.js --format=esm --jsx=react-jsx  # Automatic runtime
npx esbuild src/index.jsx --watch --servedir=dist  # Dev server
```
Config: esbuild.config.mjs для prod (minify, sourcemap).
SWC (swc.rs) — Rust-based speed demon:
Babel drop-in (faster, ~20x), supports JSX/TSX. Plugins via @swc/plugin-transform-react. Used в Next.js/Rome.
Webpack integration:
```
// swc-loader
module: { rules: [{ test: /\.jsx$/, use: 'swc-loader' }] }
```

Bundlers и dev tools (оркестраторы transpilation):

Vite (vite.dev): esbuild-powered (transpile JSX <50ms), Rollup для prod bundling. Plugin: @vitejs/plugin-react (Babel/esbuild hybrid). HMR — instant JSX updates (no full rebuild). Default для new React apps.
Setup:
```
npm create vite@latest my-app -- --template react
cd my-app && npm install
npm run dev  # Transpiles JSX on-fly, proxies /api to Go:8080
```
vite.config.js: Plugins auto-handle JSX. Perf: Cold start ~100ms, HMR ~10ms.

Webpack (webpack.js.org): Babel/esbuild loader-based. babel-loader для JSX. Slower dev (HMR ~500ms), но mature (code-split via dynamic imports). CRA/Next.js use.
Config snippet:

// webpack.config.js
module.exports = {
  module: {
    rules: [
      {
        test: /\.jsx?$/,
        use: [
          'babel-loader',  // Transpiles JSX
          { loader: 'babel-loader', options: { presets: ['@babel/preset-react'] } }
        ]
      }
    ]
  },
  plugins: [new HtmlWebpackPlugin()],  // Injects transpiled JS to index.html
};

Run: npx webpack --watch.

Next.js (nextjs.org): Full framework, SWC/esbuild default (fast builds). JSX/TSX out-of-box, SSR (transpile on server). For Go: Custom server proxy.

Runtime и продвинутые опции:

Classic vs. Automatic Runtime: Classic — explicit React.createElement (import React). Automatic (React 17+) — jsx/h functions (no import, ~30% smaller). Babel/esbuild support via flag.
TSX (JSX + TypeScript): tsc + Babel (ts-loader), или esbuild (experimental). Checks props: interface Props { name: string; } → <Comp name={name} />.
Pipeline в production: Transpile → Bundle (tree-shake unused) → Minify (terser) → Serve (Go http.FileServer для static). Tools: npm run build. Analyze: webpack-bundle-analyzer (JSX contrib ~5-10% size).
Edge cases: Dynamic tags (<Comp type={tag} /> → createElement(Comp.type, ...)), no loops in JSX (use map), comments preserved. Errors: Babel parse fail on <div> without close.

Лучшие практики для Go+React devs:

Speed First: Vite/esbuild для dev (fast feedback), Babel для complex (plugins). Monorepo: Turborepo + esbuild.
Config: Automatic runtime always (smaller), sourcemaps dev-only. Lint: eslint-plugin-react (JSX-a11y).
Integration: Go serves transpiled JS (embed.FS), React fetches /api (gorilla/mux). Shared: Go structs → TS types (openapi-generator).
Testing: Jest + babel-jest (transpiles JSX in tests: test('renders', () => { render(<App />); } )).
Perf Pitfalls: Over-nesting JSX → deep VDOM (use fragments). Large files — split components.

JSX transpilation — ключ к expressive React, с Vite/Babel/esbuild как enablers fast dev/prod cycles. В Go ecosystem: Seamless (build JS → Go serve), accelerating full-stack workflows. Для prep: Clone Vite React, run babel on single file — see the magic.

Вопрос 18. Как работает Virtual DOM в React?

Таймкод: 00:16:59

Ответ собеседника: неполный. Лёгкая копия реального DOM; при изменениях строит новую копию VDOM, сравнивает со старой, вносит только необходимые изменения в реальный DOM дешево.

Правильный ответ:
Virtual DOM (VDOM) в React — это in-memory representation реального DOM (Document Object Model) как lightweight JavaScript objects (plain JS trees), позволяющее efficiently управлять updates без прямых манипуляций costly DOM API (e.g., createElement, appendChild — slow для large trees). Работа VDOM основана на reconciliation (примирении): React builds new VDOM tree на state/props changes, diffs с previous (diffing algorithm), и applies minimal patches к real DOM. Это declarative подход: Developer описывает desired UI (via JSX → VDOM), React handles "как" update. Преимущества: Perf boost (O(n) diff vs. O(n²) full re-render), predictability (batched updates), и scalability (1M+ elements без jank). Под капотом — Fiber architecture (React 16+): Asynchronous, interruptible reconciliation для concurrent features (Suspense, Transitions). VDOM не "копия" real DOM (simplified: no layout/computed styles), а React-specific abstraction (element objects с type, props, children). В Go backend контексте: VDOM enables fast client-side rendering over JSON APIs (fetch → setState → diff → update), minimizing server load (no full HTML per request). Pitfalls: Overhead для tiny apps (VDOM cost > direct DOM), но в production (SPAs) — net win (e.g., Facebook timeline updates 1000+ nodes/sec). Senior-практика: Optimize diffs с keys (stable IDs), memoization (React.memo), и profiling (React DevTools Profiler) для bottleneck-free apps.

Структура Virtual DOM и создание:
VDOM — tree of React elements (immutable objects), generated from JSX transpilation (React.createElement или jsx). Каждый node: { type: 'div', props: { className: 'foo', children: [...] }, ref: null }. Не full DOM (no event listeners, styles computed at render), а blueprint для hydration (initial mount) или diffing.

Initial Render: JSX → VDOM tree → ReactDOM.render (mounts to real DOM, attaches events).
Update Trigger: State/props change (setState, useState) → Re-render component → New VDOM subtree.

Пример VDOM object (from JSX <div><p>Hi</p></div>):

// JSX
<div className="container">
    <p>Hello {name}</p>
</div>

// Transpiled → VDOM
{
    type: 'div',
    props: {
        className: 'container',
        children: [
            {
                type: 'p',
                props: {
                    children: ['Hello ', name, '']  // Mixed array (text, expr)
                }
            }
        ]
    }
}

Children — array для multiple, strings/numbers для text, objects для elements. Refs — для imperative access (e.g., ref.current.focus()).

Процесс Reconciliation (Diffing и Patching):
Reconciliation — core algorithm, runs on re-renders (state/props/context changes). Fiber: Work tree (linked list nodes), prioritizes updates (high: user input, low: data fetches). Steps:

Render Phase (Sync/Async): Build new VDOM tree (beginWork/endWork Fiber tasks). Components re-execute (top-down), produce elements. Memo checks (shouldComponentUpdate/React.memo) skip unchanged.
Diffing Phase: Compare new VDOM с previous (workInProgress vs. current Fiber tree). Heuristics для speed:
- Same Level Only: Diff siblings, не cross-level (assume different types → replace whole subtree). O(n) assumption.
- Element Type Check: Same type (e.g., div → div) — update props; different (div → p) — unmount old, mount new.
- Keys for Lists: Stable keys (key={id}) enable efficient reordering/insert/delete (without — O(n³) naive). Diffs children arrays via longest increasing subsequence.
- Props Diff: Shallow compare (===) props; only changed (e.g., className update) → patch. Events batched.
- Component Reuse: Same type component — reuse instance, update state/props.
Commit Phase: Apply diffs к real DOM (sync, atomic). Mutations: Insert/delete/update nodes, attach events (delegation via root container). Effects (useEffect) run post-commit.

Пример diff (simple counter):

// Initial VDOM (count=0)
{
    type: 'div',
    props: { children: ['Count: 0'] }
}

// After setState({ count: 1 }) → New VDOM
{
    type: 'div',
    props: { children: ['Count: 1'] }
}

// Diff: Same type, props.children[1]

Вопрос 19. Как именно происходит сравнение в Virtual DOM, учитывая ссылочные типы объектов?

Таймкод: 00:17:40

Ответ собеседника: неполный. Проходит по узлам и внутренним полям объектов; связано с иммутабельностью - возвращать новые копии для триггера изменений, так как ссылки разные.

Правильный ответ:
Сравнение в Virtual DOM (VDOM) — это core часть reconciliation process в React, известного как diffing algorithm, который работает на уровне Fiber nodes (internal representation VDOM как linked list для async processing). Diffing происходит во время render phase (beginWork/endWork), где React сравнивает new VDOM tree (workInProgress) с previous (current Fiber tree), определяя minimal changes для commit phase (real DOM patches). Алгоритм heuristic-based для efficiency: O(n) time в average (linear scan по tree, не full pairwise), полагаясь на assumptions вроде "different types mean different trees" и stable keys. Для ссылочных типов (objects, arrays, functions) сравнение shallow (=== reference equality), без deep traversal (чтобы avoid O(n²) cost), что требует immutable patterns от devs (return new objects для trigger diffs). Это предотвращает unnecessary re-renders, но pitfalls: Mutable props (e.g., shared object) не trigger update если reference same, даже если contents changed. В production senior-практика: Use immutable updates (spread operator, Immer), keys для lists, и memoization (useMemo, React.memo) для optimize shallow checks. В Go backend интеграции: React diffs JSON props (fetched from /api), ensuring efficient UI updates без full re-mount. Без immutability diffing fails (silent bugs), так что всегда benchmark с React Profiler (highlight updates).

Основные принципы diffing и сравнения узлов:
Diffing — recursive, top-down traversal VDOM tree, starting от root (e.g., <App />). Для каждого node:

Type Check: Если types differ (e.g., 'div' → 'span' или <CompA> → <CompB>), unmount old subtree, mount new (full replace, no diff). Assumption: Different types unlikely same structure.
Props Comparison: Для same type — shallow compare props object (Object.keys loop, === per value). Attributes (className, style) и event handlers (onClick) checked individually. Changed prop → patch (e.g., setAttribute). Children — recursive diff.
Children Diff: Lists (arrays) — special: Without keys — naive O(n³) (stable subsequence), with keys — O(n) map-by-key (treat as objects). Insert/delete/reorder based on key presence.
Reference Handling: Slices (objects/arrays/functions) — shallow === (same reference? No deep equals). If props.children = oldArray (same ref, but mutated) — no update, even changed contents. Trigger: New ref (e.g., [...oldArray, newItem]).
Component Boundary: Для custom components — diff at boundary (props to child), child manages internal (e.g., <List items={newItems} /> diffs items prop).

Heuristics optimize: No cross-level diff (sibling only), no prop diff если type changed. Fiber enables pausing (yield to browser для 60fps), batching multiple renders.

Пример базового diff (simple list):

// Initial VDOM (items = [{id:1, text:'A'}, {id:2, text:'B'}])
[
    { type: 'li', key: '1', props: { children: 'A' } },
    { type: 'li', key: '2', props: { children: 'B' } }
]

// New VDOM after setItems (add {id:3, text:'C'}, reorder)
[
    { type: 'li', key: '2', props: { children: 'B' } },  // Reorder
    { type: 'li', key: '1', props: { children: 'A' } },
    { type: 'li', key: '3', props: { children: 'C' } }  // Insert
]

// Diff Process:
// - Map by keys: Old {1:'A', 2:'B'}, New {2:'B', 1:'A', 3:'C'}
// - Key '2': Same position? No, but same type/props → move node
// - Key '1': Same, but position changed → move
// - Key '3': New → insert after
// - No old keys missing → no delete
// Result: 2 moves + 1 insert (minimal DOM ops: appendChild, insertBefore)

Без keys: React assumes order-based (stable subsequence: Keep 'A','B' in order, insert 'C' — O(n³) worst). Keys — hashed (React internals), stable IDs (e.g., user.id) critical.

Учёт ссылочных типов в сравнении:
Ссылочные типы (objects/arrays/functions) — common в props (e.g., style={{color:'red'}}, onClick=handler, children array). Diffing shallow:

Object/Array Props: === checks reference. If same ref — no update, даже mutated (e.g., props.data.push(item) — silent fail). Solution: Immutable update (return new obj).
Pitfall и fix:

// Bad: Mutable prop (same ref, no diff trigger)
const [data, setData] = useState({ users: [] });
const addUser = (user) => {
    data.users.push(user);  // Mutate shared object
    setData(data);  // Same ref → No re-render!
};

// Good: Immutable (new ref → diff detects change)
const addUserImmutable = (user) => {
    setData(prev => ({ ...prev, users: [...prev.users, user] }));  // New objects
};
// Diff: props.users === old? No (new array) → Update children list

Deep equality rare (costly, libs like lodash.isEqual), so immutability convention (always new refs for state).

Function Props: === on handler (e.g., onClick={handleClick}). Inline () => {} — new func each render, always diff (re-attach event). Fix: useCallback.

const [count, setCount] = useState(0);
const increment = useCallback(() => setCount(c => c + 1), []);  // Stable ref

return <button onClick={increment}>+</button>;  // Same ref → No re-diff if props same

Without: Each render new func → Child re-render (perf loss).

Children as Refs: Array children — diffed by index/keys. If children={oldArray} (mutated) — no update. Immutable: [...oldChildren, newElement].

Fiber и advanced diffing:
Fiber nodes: Each VDOM element — Fiber { type, props, child, sibling, return (parent), stateNode }. Diffing walks child/sibling. Alternate: Double buffering (current + workInProgress), swap on commit. Concurrent: Prioritize (lanes: urgent user input vs. idle data fetch). Effects (useLayoutEffect post-diff pre-commit, useEffect post-commit).

Пример с reference-sensitive diff (memoized component):

import React, { memo, useMemo } from 'react';

const ExpensiveList = memo(({ items }) => {  // Memo: Skip if props shallow equal
    console.log('List rendered');  // Logs only on change
    return (
        <ul>
            {items.map(item => <li key={item.id}>{item.name}</li>)}  // Keyed diff
        </ul>
    );
});

function App() {
    const [items, setItems] = useState([{id:1, name:'A'}]);
    const memoItems = useMemo(() => items, [items]);  // Stable ref if items same

    const add = () => {
        setItems(prev => [...prev, {id: prev.length + 1, name: 'B'}]);  // New array ref
    };

    return (
        <div>
            <button onClick={add}>Add</button>
            <ExpensiveList items={memoItems} />  // Diff: items ref changed → re-render
        </div>
    );
}

Memo skips if items === oldItems (shallow). useMemo ensures ref stability unless deps change.

Лучшие практики и pitfalls:

Immutability Always: Use spread/immutable libs (Immer: produce(state, draft => draft.arr.push(x))) для new refs. Avoid mutate (e.g., props.obj.key = val — no trigger).
Keys Stable: Unique/non-index (key={user.id}, not key={index} — breaks reorder).
Shallow Optimization: React.memo для pure components (shallow props/children compare). useMemo для expensive objects (e.g., computed style).
Perf Monitoring: React DevTools: Profiler records diffs (whyDidYouRender lib для deep logs). Avoid over-memo (overhead).
Edge Cases: Functions in props — unstable without callback; nested objects — shallow only (mutate deep — no detect). Lists with dynamic keys — remount (lost focus/state).
With Go: Fetch JSON → setState(newObj) (immutable) → Diff triggers list update (e.g., users from /api/users).

Diffing — efficient via shallow refs + heuristics, forcing immutability для correctness. В large apps (e.g., 10k nodes) — 100x faster direct DOM, enabling smooth UIs over Go APIs. Для prep: Use whyDidYouRender hook — see reference fails firsthand.

Вопрос 20. Что делает React после сравнения Virtual DOM?

Таймкод: 00:19:07

Ответ собеседника: правильный. Перерендеривает только изменившиеся части.

Правильный ответ:
После сравнения Virtual DOM (diffing в reconciliation phase) React переходит к commit phase — финальному этапу обновления, где computed minimal changes (patches) применяются к реальному DOM (browser's DOM tree). Это atomic, synchronous процесс (no interruptions, для consistency), батчинг multiple mutations (e.g., insert + update) для perf. React не "перерендеривает" (full re-render — build new VDOM), а precisely patches: Inserts/deletes/updates nodes, sets attributes/events, based on diff results (e.g., only changed <li> text, not whole list). Под капотом — Fiber commitRoot (traverses effect list: DOM mutations, effects). Это обеспечивает targeted updates (O(1) per change vs. O(n) full), минимизируя reflows/repaints (browser costly ops). В production: Batched commits (multiple setState → one patch), с layout effects (useLayoutEffect pre-paint) и effects (useEffect post-paint). Для Go backend: Patches enable responsive UI на JSON updates (fetch → setState → diff → patch single element), без full reload. Pitfalls: Unkeyed lists — excessive patches (remounts); mutable refs — skipped updates. Senior-практика: Use keys/memo для minimize diffs, profile commits (React DevTools: Record why updates), и concurrent mode (18+) для non-blocking patches (Transitions). Commit — bridge VDOM to real DOM, enabling declarative → imperative transition efficiently.

Commit Phase: Шаги после diffing:
Reconciliation (render phase) produces effect list (side-effects: mutations, effects) на Fiber tree (workInProgress → current swap). Commit — applies to DOM/container. Phases:

Pre-Commit (Layout Effects): Sync traversal effect list (high priority). Run useLayoutEffect callbacks (e.g., measure DOM post-update pre-paint). DOM mutations first:
- Insert: Create real node (document.createElement), append/insertBefore to parent. For keyed — reuse if possible (moveNode).
- Delete: Remove child (parent.removeChild), unmount components (run cleanup).
- Update: Set attributes (node.setAttribute), textContent, replace nodes (if type changed). Events: Attach via delegation (root addEventListener, synthetic events).
- Placement: Reorder (insertBefore for moves).
  Batched: Queue ops, flush atomically (no partial visible state).
Flush Layout Effects: Call useLayoutEffect (e.g., ref.current.scrollIntoView()).
Post-Commit (Effects): Async (microtask), run useEffect (e.g., fetch data). Swap Fiber trees (current = workInProgress).

Пример commit (counter update):

// Diff result: <span id="count">1</span> → <span id="count">2</span>
// Commit:
// 1. Traverse effect: Update text node
// 2. node.textContent

Вопрос 21. Какие триггеры вызывают перерендер компонента в React?

Таймкод: 00:19:25

Ответ собеседника: неполный. Изменение state или props; рендер родителя, изменение контекста.

Правильный ответ:
Перерендер компонента в React — это процесс повторного выполнения функции компонента (functional) или метода render() (class), который генерирует новый Virtual DOM subtree для последующего diffing и patching реального DOM. Триггеры re-render — изменения в "входах" компонента (inputs), которые React отслеживает для declarative обновлений UI. React работает с принципом unidirectional data flow: Changes propagate top-down (parent → child), с batching (multiple triggers → one re-render в event loop). Основные триггеры: локальный state (useState/setState), props (от parent), context (provider value). Дополнительные: Re-render parent (cascade, unless memoized), force updates (rare). Нет re-render на stable refs (=== same), или если skipped (React.memo, shouldComponentUpdate). В production это критично для perf: Unnecessary re-renders (e.g., 100 children on parent state) waste CPU/GC, так что optimize с immutability (new refs) и memoization. Для Go backend: Re-renders trigger on API responses (fetch → setState(newData) → diff → targeted patch), enabling reactive UIs без full reloads. Pitfalls: Inline functions/objects в props — new ref each render → child re-render. Senior-практика: Profile (React DevTools: Why did this render?), use useMemo/useCallback для stable deps, и concurrent mode (React 18+) для prioritization (user input > data fetches). Re-renders — data-driven, controlled via refs и heuristics.

Основные триггеры re-render:

Изменение локального State:
Самый прямой триггер: Вызов setter (setState в class, useState updater в functional) schedules re-render. React compares new value с old (shallow === для primitives/objects). Для refs (arrays/objects) — new reference required (immutable update: [...old, new]). Batching: Multiple sets в одном event → one re-render (final value). Async: Updater functions (setCount(c => c + 1)) safe для closures.
Пример (functional с useState):
```
import React, { useState } from 'react';

function Counter() {
    const [count, setCount] = useState(0);  // Initial render

    const increment = () => {
        setCount(c => c + 1);  // Trigger: Schedules re-render
        setCount(c => c + 2);  // Batched: Final c+2 (one re-render)
    };

    console.log('Re-render triggered');  // Logs on setCount
    return <button onClick={increment}>Count: {count}</button>;
}
```
Class equiv: this.setState({ count: this.state.count + 1 }) — same. No re-render if setCount(sameValue) (optimized).

Изменение Props:
Parent re-render passes new props → Child checks if props !== oldProps (shallow compare refs). Trigger если any prop changed (e.g., { name: newString }). Inline (onClick={() => ...}, style={{...}}) — new object/func each parent render → child always. Fix: useCallback/useMemo для stable refs.
Пример:

function Parent() {
    const [name, setName] = useState('Alice');
    const stableHandler = () => alert('Stable');  // Without useCallback — new each time

    const changeName = () => setName('Bob');  // Parent state change

    return (
        <Child 
            name={name}  // New prop → child re-render
            onClick={stableHandler}  // Stable ref → no trigger if same
            onClickInline={() => alert('Inline')}  // New func → trigger
        />
    );
}

function Child({ name, onClick, onClickInline }) {
    console.log('Child re-render');  // Triggers on name/onClickInline change
    return <p onClick={onClick} onClickInline={onClickInline}>{name}</p>;
}

useCallback(onClick, [deps]) ensures ref stability (no re-render child if deps same).

Изменение Context:
Provider value change (new ref) → All consumers (useContext) re-render, даже без direct props. Top-level trigger (bubbles to subtree). Granular: Separate contexts (Theme vs. User) limit scope.
Пример:

import React, { createContext, useContext, useState } from 'react';

const UserContext = createContext();

function App() {
    const [user, setUser] = useState({ name: 'Alice' });

    const updateUser = () => setUser({ name: 'Bob' });  // New object → context change

    return (
        <UserContext.Provider value={user}>  // Value ref change → consumers re-render
            <button onClick={updateUser}>Update</button>
            <UserProfile />
        </UserContext.Provider>
    );
}

function UserProfile() {
    const user = useContext(UserContext);  // Re-renders on provider value change
    console.log('Profile re-render');
    return <p>User: {user.name}</p>;
}

If value stable (useMemo(() => ({...user}), [user.name])) — no trigger on shallow changes.

Дополнительные триггеры:

Re-render Родительского Компонента:
Parent re-render → Child always re-executes (tree traversal), даже если props/context stable. Cascade: Affects whole subtree. Skip: React.memo (shallow props check), PureComponent (shallow state/props).
Пример:

function Grandparent() {
    const [trigger, setTrigger] = useState(0);

    return (
        <div>
            <button onClick={() => setTrigger(t => t + 1)}>Trigger</button>
            <Parent />  // Parent re-renders on state
        </div>
    );
}

function Parent() {
    console.log('Parent re-render');  // Triggers on grandparent
    return <Child />;  // Child re-renders (no props, but parent did)
}

const Child = React.memo(() => {  // Memo: Skips if no props change
    console.log('Child re-render');  // Skipped if memo active
    return <p>Child</p>;
});

Without memo — child always; with — only if parent passes changed props.

Force Re-render (Императивный, Rare):

Class Components: this.forceUpdate() — bypasses all checks, forces render (e.g., reset after mutation). Avoid (breaks declarative).
Functional: Change key prop on parent (e.g., <Comp key=0.9124062682844432 /> — unmount/remount, full re-init). Or dummy state (const [key, setKey] = useState(0); setKey(k => k + 1)). Use для side-effects (e.g., re-init chart).
Пример:

function Form() {
    const [key, setKey] = useState(0);
    const [force, setForce] = useState(0);

    const reset = () => {
        setForce(f => f + 1);  // Dummy trigger
        // Or <Input key={key} />; setKey(k => k + 1); — remount
    };

    return (
        <div>
            <Input force={force} />  // Re-renders on dummy prop
            <button onClick={reset}>Reset</button>
        </div>
    );
}

Механизмы Batching и No Re-render Cases:

Batching: React 18+ auto-batches (events/Promises → one re-render). Manual: unstable_batchedUpdates (legacy).
No Re-render:
- Stable inputs (props/state === old).
- Memoized (React.memo: props shallow equal).
- Unmounted (cleanup).
- Error boundaries catch, но не prevent.

Лучшие практики для управления re-renders:

Immutability: Always new refs (setState({ ...old, new: val })). Libs: Immer (draft mutations → new state).
Stabilize Props: useMemo (objects: const style = useMemo(() => ({color: theme}), [theme])), useCallback (funcs).
Granular State: Multiple useState (count, loading) vs. one object (finer triggers).
Context Optimization: useMemo for value, multiple providers.
Memo Components: React.memo for pure (e.g., const ListItem = memo(({item}) => ...)).
Profile Tools: React DevTools (Profiler: Record → see triggers/tree), why-did-you-render (logs causes). Benchmark: Avoid over-memo (costly checks).
Concurrent React (18+): useTransition для low-priority (setTransitionState → non-blocking re-render).
With Go: API → useEffect(fetch) → setData(newRes) (immutable) → Re-render list (targeted, no full app).

Re-renders efficient via batching/shallow checks, но control essential для scalable UIs (e.g., dashboard with 1000 rows). В Go+React: Async data (goroutines/channels → JSON → setState) triggers minimal updates, keeping responsive. Для prep: Add logs in components — observe parent cascade on state change.

Вопрос 22. В чём разница при прокидывании обычной функции и мемоизированной с useCallback в обычный компонент без обёрток?

Таймкод: 00:21:22

Ответ собеседника: неправильный. Не уверен, думаю нет разницы, так как обе - функции; useCallback для оптимизации выполнения, но не понимает роль в сохранении ссылки для предотвращения рендеров.

Правильный ответ:
При прокидывании функций как props в обычный (non-memoized) дочерний компонент без обёрток (т.е. без React.memo или PureComponent) разница между обычной функцией и мемоизированной с useCallback не в прямом предотвращении re-render'ов child (поскольку child всегда re-renders при parent render, независимо от props stability), а в subtle perf benefits: stable reference для dependency arrays (useEffect/useMemo в child), avoidance unnecessary computations (e.g., inline calls), и future-proofing (если позже добавить memo на child — stable func skips). Обычная функция (inline () => {} или defined в body) создаёт new reference на каждом parent render (closure), что не affects child re-render directly (React не shallow-compares props без memo), но breaks child hooks deps (e.g., useEffect([onClick]) re-runs each time). useCallback(fn, deps) возвращает memoized func с stable ref (same === previous если deps unchanged), enabling child to cache (e.g., no re-run effects) и reducing work в deep trees (e.g., list of 1000 items — stable onClick avoids 1000 re-closures). Overhead useCallback minimal (hook call), но win в apps с frequent parent renders (e.g., timers, API polls). В Go backend: Stable funcs ensure child effects (fetch onClick) не thrash на data updates (setData → parent render → stable prop). Без useCallback — simple apps ok (no perf hit), но scalable UIs (forms/tables) accumulate waste (closures, effect re-runs). Senior-практика: Always useCallback для prop funcs (even without memo), ESLint exhaustive-deps для deps, и profile (DevTools: Check effect triggers). Разница indirect, но critical для maintainable perf — ordinary func pollutes, memoized cleans.

Reference Stability и Prop Passing:
Обычная функция — recreated each parent render: New closure (captures current scope), new ref (fn1 !== fn2). При pass как prop: Child receives it, but without memo — child re-executes anyway (tree traversal). Однако:

Child useEffect/useMemo с [onClick] — deps new ref → re-run (e.g., re-fetch API on every parent render).
Inline in child (e.g., <Sub onSubClick={() => onClick(id)} />) — new closure each child render, compounding waste.

useCallback: Wraps fn, caches (internal map/ref), returns same func если deps === old (shallow array compare). Deps — primitives/refs (e.g., [id, user.id]). Recompute only on change.

Пример без обёрток (focus на child effects):

import React, { useState, useEffect } from 'react';

function Parent() {
    const [count, setCount] = useState(0);
    const [id, setId] = useState(1);

    // Ordinary function: New ref each render
    const handleClick = () => {
        console.log('Clicked:', id);  // Logs current id
        setId(id + 1);
    };

    // Or inline: const handleInline = () => setId(id + 1);  // New each time

    const increment = () => setCount(c => c + 1);  // Triggers parent re-render

    return (
        <div>
            <button onClick={increment}>Parent Count: {count}</button>
            <Child onClick={handleClick} />  // New ref each parent render
        </div>
    );
}

function Child({ onClick }) {  // No memo — re-renders on parent always
    console.log('Child render');  // Logs every parent re-render

    useEffect(() => {
        console.log('Child effect: onClick changed');  // Runs every time (new ref)
        // e.g., Setup listener: window.addEventListener('resize', onClick); — re-adds!
        return () => console.log('Cleanup effect');
    }, [onClick]);  // Deps: New func ref → re-run each parent render

    return <button onClick={onClick}>Child Button</button>;
}

Здесь: Parent increment → re-render → new handleClick ref → Child re-render (from parent) + effect re-run (new dep). Waste: Unnecessary cleanup/setup (e.g., API subscribe/unsubscribe thrash).

С useCallback (stable ref, effect skips):

function Parent() {
    const [count, setCount] = useState(0);
    const [id, setId] = useState(1);

    // Memoized: Stable ref if deps same
    const handleClick = useCallback(() => {
        console.log('Clicked:', id);  // Captures current id (closure)
        setId(id + 1);
    }, [id]);  // Re-deps only if id changes

    const increment = () => setCount(c => c + 1);

    return (
        <div>
            <button onClick={increment}>Parent Count: {count}</button>
            <Child onClick={handleClick} />  // Same ref if id unchanged
        </div>
    );
}

function Child({ onClick }) {
    console.log('Child render');  // Still on parent re-render

    useEffect(() => {
        console.log('Child effect: onClick changed');  // Runs only if id changed (deps stable)
        // Setup once, no thrash
        return () => console.log('Cleanup');
    }, [onClick]);  // Stable ref → Skip re-run if parent renders without id change

    return <button onClick={onClick}>Child Button</button>;
}

Разница: Increment (no id change) → Parent re-render → Child re-render (unavoidable without memo), but effect skips (onClick === old). Click → id change → deps change → effect re-run (correct). Win: No wasteful re-subscribes (e.g., event listeners, timers).

Влияние без обёрток (memo):

Re-render Child: Always от parent (tree walk), regardless func stability. Разница не в skip render, а в child internals: Stable func — child computations/effects cheaper (no re-closures, stable deps).
Inline in Child: <Grandchild onGrand={onClick => ...} /> — new closure each child render. Stable onClick — still new, but if onClick stable, less mutation.
Deep Trees: List <Item onItemClick={handleItem} key={i} /> x1000 — ordinary: 1000 new funcs each parent render (memory/GC). useCallback: 1000 stable refs (one compute).

Когда разница критична (даже без memo):

Child Hooks: useEffect([props.func]) — stable avoids re-runs (e.g., resize listener re-adds).
Child Computations: useMemo([props.func]) — stable dep skips recompute.
Event Bubbling: Synthetic events — stable handlers preserve delegation efficiency.
Future Memo: Add React.memo(Child) later — stable func enables skip (shallow props: onClick === old → no render).

С memo (full optimization):

const Child = React.memo(Child);  // Now skips if props shallow equal

// With ordinary: Parent render → new onClick → !equal → render
// With useCallback: Parent render (no deps change) → onClick === old → skip render

Без useCallback memo useless для func props (always new ref → always render).

Best Practices и Trade-offs:

Always Memo Func Props: useCallback для onClick/onSubmit/etc. (deps: Primitives/refs, no functions/objects unless memoized).
Deps Management: ESLint react-hooks/exhaustive-deps warns missing. Empty [] — fixed (e.g., no deps).
Overhead: useCallback ~5-10% slower small apps (hook), но scales (large lists). Profile: If <1% time — ok.
Alternatives: Define outside (const globalHandler = () => ... — pollutes, no closure). Class bind (constructor: this.handle = this.handle.bind(this) — legacy, one-time).
With Go: Stable onLoad={useCallback(() => fetch('/api'), [])} — Effect runs once, no re-fetch on parent polls.
Testing: Jest: Mock stable funcs (jest.fn() === same), check effect calls (expect(effectMock).toHaveBeenCalledTimes(1)).

Разница — в stability для child efficiency (effects, computations), не direct render skip без memo. В non-memo child — subtle (no thrash), но essential для clean code/perf. Добавь memo — full power. Для prep: Log refs (console.log(onClick) in child) — see new vs. same.

Вопрос 23. Для чего нужны хуки в React?

Таймкод: 00:23:23

Ответ собеседника: неполный. Готовые функции для управления состояниями, контекстами и компонентами.

Правильный ответ:
Хуки в React — это специальные функции (начинающиеся с "use"), которые позволяют добавлять state, side-effects, контекст и другие React-функции в функциональные компоненты, делая их полноценной альтернативой классовым компонентам. Они введены в версии 16.8 (2019) для решения проблем классов: сложность с "this" (binding, lexical scope), переиспользование логики (HOC/render props boilerplate), и разделение concerns (state/logic в отдельных методах). Хуки позволяют извлекать reusable stateful logic в custom hooks (e.g., useAuth для аутентификации), компоновать их (composition: useEffect + useState), и держать код колокейтированным (logic рядом с UI). Built-in hooks (useState, useEffect, useContext) — базовые primitives; custom — пользовательские (useFetch для API). Преимущества: Упрощение (no lifecycle methods, no this pitfalls), переиспользуемость (hook в любом компоненте), предсказуемость (rules: top-level calls, no conditionals), и perf (deps control re-runs). В production hooks ускоряют dev (one-file components), testing (renderHook), и scalability (logic separation: UI + hooks). Для Go backend: Hooks manage API interactions (useEffect(fetch('/api'))), state (useState for form data → POST), enabling reactive UIs (data → render без reloads). Pitfalls: Rules violations (linter fixes), deps staleness (ESLint exhaustive-deps). Senior-практика: Custom hooks для patterns (forms, auth), combine (useReducer + useContext для global state), и concurrent (useTransition 18+). Hooks — foundation functional React (classes legacy), reusable от simple buttons до complex apps (e.g., dashboards с useQuery).

Хуки следуют rules: Вызывать только на top-level в functional components или custom hooks (no loops/if — React tracks by order), и всегда в том же порядке (predictable execution). Нарушение — bugs (stale state, missed effects).

Built-in Hooks: Основные и их цели
Built-in — primitives для core features. Они re-run на каждом render, но effects/memos control via deps.

useState: Добавляет локальный state (primitive/object/array) к компоненту. Возвращает [value, setter]. Setter schedules re-render (batched, async), updater fn (set(v => v + 1)) для immutability/derived. Re-renders только на set (shallow compare).
Цель: Simple state (counters, forms, toggles). Multiple states — granular (separate re-renders).
Пример (form state):

import React, { useState } from 'react';

function LoginForm() {
    const [email, setEmail] = useState('');  // String state
    const [password, setPassword] = useState('');  // Separate for fine control
    const [loading, setLoading] = useState(false);  // Boolean toggle

    const handleSubmit = async (e) => {
        e.preventDefault();
        setLoading(true);  // Triggers re-render (show spinner)
        try {
            const res = await fetch('/api/login', {  // Go backend
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({ email, password })
            });
            if (res.ok) {
                // Success: Redirect or set global state
            }
        } catch (err) {
            console.error('Login failed:', err);
        } finally {
            setLoading(false);  // Re-render: Hide spinner
        }
    };

    return (
        <form onSubmit={handleSubmit}>
            <input
                value={email}
                onChange={(e) => setEmail(e.target.value)}  // Controlled input
                placeholder="Email"
            />
            <input
                type="password"
                value={password}
                onChange={(e) => setPassword(e.target.value)}
                placeholder="Password"
            />
            <button type="submit" disabled={loading}>
                {loading ? 'Logging in...' : 'Login'}
            </button>
        </form>
    );
}

Без useState — manual refs/DOM, error-prone. Updater: setEmail(e.target.value) — current value.

useEffect: Управляет side-effects (API calls, timers, subscriptions, DOM). Runs after render (post-paint, async), cleanup (return fn) on unmount/re-run. Deps [] — once (mount), [id] — on change, no deps — every render.
Цель: Lifecycle (fetch on mount, cleanup on unmount), async ops (integrate Go APIs). useLayoutEffect — sync pre-paint (e.g., measurements).
Пример (API fetch + cleanup):

import React, { useState, useEffect } from 'react';

function UserDashboard({ userId }) {
    const [data, setData] = useState(null);
    const [error, setError] = useState(null);

    useEffect(() => {
        if (!userId) return;  // Guard (no effect if missing)

        let abortController = new AbortController();  // Cancel on unmount

        fetch(`/api/dashboard/${userId}`, { signal: abortController.signal })  // Go: /api/dashboard/:id
            .then(res => {
                if (!res.ok) throw new Error('Failed to fetch');
                return res.json();
            })
            .then(setData)
            .catch(err => {
                if (err.name !== 'AbortError') setError(err.message);
            });

        return () => {  // Cleanup: Abort on unmount/deps change
            abortController.abort();
            console.log('Effect cleanup');
        };
    }, [userId]);  // Re-run only if userId changes

    if (error) return <div>Error: {error}</div>;
    if (!data) return <div>Loading...</div>;

    return (
        <div>
            <h1>Dashboard for User {userId}</h1>
            <p>Stats: {data.visits}</p>
        </div>
    );
}

Cleanup prevents leaks (e.g., memory from subscriptions). No deps — infinite loop risk.

useContext: Подписывается на context value. Re-renders on provider change (shallow ref).
Цель: Prop drilling avoidance (global state: theme, auth). Simpler than <Context.Consumer>.
Пример (global auth):

import React, { createContext, useContext, useState } from 'react';

const AuthContext = createContext();

export function useAuth() {  // Custom helper
    const context = useContext(AuthContext);
    if (!context) throw new Error('useAuth must be in AuthProvider');
    return context;
}

function AuthProvider({ children }) {
    const [user, setUser] = useState(null);
    const login = (credentials) => {
        // Fetch from Go: POST /api/auth
        fetch('/api/auth', { method: 'POST', body: JSON.stringify(credentials) })
            .then(res => res.json())
            .then(setUser);
    };

    return (
        <AuthContext.Provider value={{ user, login, logout: () => setUser(null) }}>
            {children}
        </AuthContext.Provider>
    );
}

function Profile() {
    const { user, login } = useAuth();  // Re-renders on context change
    return user ? <p>Welcome, {user.name}</p> : <button onClick={() => login({email:'test'})}>Login</button>;
}

// App: <AuthProvider><Profile /></AuthProvider>

useAuth — custom hook, reusable.

Custom Hooks: Переиспользование и Композиция
Custom hooks — functions (use*) calling built-in, extracting logic (e.g., forms, API). Reusable (import/use в любом component), composable (useFetch + useLocalStorage).
Пример (API hook, integrates Go):

import { useState, useEffect } from 'react';

function useApi(url, options = {}) {
    const [data, setData] = useState(null);
    const [loading, setLoading] = useState(true);
    const [error, setError] = useState(null);

    useEffect(() => {
        setLoading(true);
        fetch(url, options)  // e.g., { method: 'POST', body: JSON.stringify(payload) }
            .then(res => {
                if (!res.ok) throw new Error(`HTTP ${res.status}`);
                return res.json();  // Go: json.NewEncoder(w).Encode(data)
            })
            .then(setData)
            .catch(setError)
            .finally(() => setLoading(false));
    }, [url, options]);  // Re-run on url/options change

    const refetch = () => {/* Trigger again */};

    return { data, loading, error, refetch };
}

// Usage: Reusable in multiple components
function PostsList() {
    const { data: posts, loading } = useApi('/api/posts');  // GET from Go
    if (loading) return <div>Loading posts...</div>;
    return (
        <ul>
            {posts?.map(post => <li key={post.id}>{post.title}</li>)}
        </ul>
    );
}

function CreatePost() {
    const { refetch } = useApi('/api/posts');
    const handleSubmit = (formData) => {
        useApi('/api/posts', {  // POST to Go
            method: 'POST',
            body: JSON.stringify(formData)
        });
        refetch();  // Refresh list
    };
    // Form logic...
}

useApi — composable (useState + useEffect), testable (renderHook(() => useApi(url))).

Другие Built-in Hooks и Расширения:

useReducer: State machine (dispatch(action) → reducer(state, action)). Для complex (e.g., forms с validation).

const [state, dispatch] = useReducer((state, action) => {
    switch (action.type) {
        case 'INCREMENT': return { ...state, count: state.count + 1 };
        default: return state;
    }
}, { count: 0 });

useMemo: Memoizes value (compute, deps) — stable ref, skips recompute. Для expensive (filter large array).
useCallback: Memoizes function (fn, deps) — stable ref для props (avoids child re-renders).
useRef: Mutable object (current = val), no re-render. Для DOM refs (input.focus()), previous values (prevCount = useRef()).
useImperativeHandle: Customizes ref exposure (with forwardRef).
useId/useTransition (18+): Unique IDs (a11y), non-blocking updates (setTransitionState).

Преимущества Hooks:

Reusability: Custom hooks share logic (no HOCs: useFetch в 10 components).
Simplicity: Functional (no super, bind), colocation (state/effects в render).
Perf: Deps granular (useEffect([id]) re-runs only on id, not every).
Testing: Isolated (test useAuth() standalone).
Composition: Hooks inside hooks (useApi calls useLocalStorage).

Правила и Ошибки:

Top-level calls only (no if/loops — order matters). ESLint react-hooks/rules-of-hooks.
Deps: Include all (stale closures: use old state). exhaustive-deps fixes.
Custom: Prefix "use", call only in components/hooks.

В Go+React Контексте:
Hooks bridge async (useEffect for goroutines/JSON), state (useState for responses). Custom useGoApi — reusable для /users, /posts (fetch + error handling). Scalable: Hooks + Go = Data-driven UIs (channel → JSON → hook → render).

Хуки — superpower functional React, для state/effects reuse. Prep: Build useCounter (useState + useEffect for timer) — feel modularity.

Вопрос 24. Почему в React использовать useState вместо обычной переменной?

Таймкод: 00:23:54

Ответ собеседника: правильный. Переменная сбрасывается при каждом рендере, useState сохраняет значение между рендерами.

Правильный ответ:
В React использование useState вместо обычной переменной (let/const) необходимо для обеспечения persistent state между re-renders компонента: Обычная переменная reinitialized на каждом вызове функции компонента (functional component — это функция, которая re-executes top-to-bottom при триггерах вроде setState/props/context), сбрасывая значение к initial (e.g., let count = 0 всегда 0), в то время как useState — это hook, который internally stores state в React's Fiber tree (associated с component instance), возвращая [currentValue, setter], где setter schedules re-render с updated value (shallow comparison для skip if unchanged). Это делает state declarative и reactive: Changes trigger targeted VDOM diff/patch, без manual persistence (e.g., localStorage — async/slow). useState — primitive для local state (primitives, objects, arrays), с immutable updates (new refs для trigger diffs). Без него компонент — pure function (stateless, resets always), fine для UI (render from props), но бесполезен для interactivity (forms, counters — lose input). В production: Granular multiple useState (separate re-renders), updater functions (set(v => v + 1)) для safe derived values. Для Go backend: useState holds API responses (setUsers(res.json()) — immutable), enabling reactive UI (data → re-render list без reload). Alternatives: useReducer для complex logic, Context для shared. Pitfalls: Mutable state (mutate obj — no re-render), over-use (perf: 1000 states — waste). Senior-практика: Immutable libs (Immer: draft mutate → new state), lazy initial (useState(() => compute())), и profiling (DevTools: Track state changes). useState — core для dynamic apps, bridging declarative UI с imperative interactions.

Почему обычная переменная сбрасывается:
Functional components — pure functions, re-called on re-render (parent/props/state change). Local vars (let count = 0) — scoped to invocation, reset each time (no "memory"). Changes lost post-render.
Пример без useState (resets on re-render):

import React from 'react';

function Counter() {
    let count = 0;  // Resets to 0 each render

    const increment = () => {
        count++;  // Local change, but lost on next render
        console.log('Incremented to:', count);  // Logs 1, but UI?
    };

    console.log('Render with count:', count);  // Always 0
    return <button onClick={increment}>Count: {count}</button>;  // UI always 0
}

Click: count=1 (log), but event triggers re-render (from React scheduler) → count=0 (reset), UI unchanged. No persistence — component "forgets".

Как useState обеспечивает persistence и reactivity:
useState(initial) — hook, first render: value = initial (or lazy fn result). Subsequent: value = last set value (from internal store). Setter (setState) queues update (batching: multiple → one re-render), triggers reconciliation (VDOM diff → patch). Shallow check: Set same value — no re-render (optimized).
Пример с useState (persists across re-renders):

import React, { useState } from 'react';

function Counter() {
    const [count, setCount] = useState(0);  // Persisted: 0 → 1 → 2...

    const increment = () => {
        // setCount(count + 1);  // Uses current (closure-safe? No, stale possible)
        setCount(c => c + 1);  // Updater: Always latest, immutable
    };

    console.log('Render with count:', count);  // 0 → 1 → 2...
    return <button onClick={increment}>Count: {count}</button>;  // UI updates
}

Click: setCount(1) → re-render → count=1 (from React's store). Multiple clicks: Persists, UI reactive. Updater avoids stale closures (e.g., in async/setTimeout).

Ключевые отличия в механике и использовании:

Persistence: Var — per-render (ephemeral), useState — cross-render (durable, Fiber-backed).
Re-render Trigger: setState — yes (schedules diff/patch), var change — no (local, React unaware).
Initial/Lazy: useState(0) — eager (always), useState(() => { const data = expensiveCompute(); return data; }) — lazy (once). Var — always eager/reset.
Immutability & Refs: For objects: setObj({ ...old, newKey: val }) — new ref triggers diff. Mutate old (obj.key = val; setObj(obj)) — no trigger (shallow === same). Var — no trigger anyway.
Batching: useState sets batched (React 18+: auto in events/Promises → one re-render). Var — immediate but lost.

Пример с object state и API (Go integration):

import React, { useState } from 'react';

function UserManager() {
    const [formData, setFormData] = useState({ name: '', email: '' });  // Persists form
    const [users, setUsers] = useState([]);  // Persists list

    const handleInput = (field) => (e) => {
        setFormData(prev => ({ ...prev, [field]: e.target.value }));  // Immutable, new ref
    };

    const addUser = async (e) => {
        e.preventDefault();
        const res = await fetch('/api/users', {  // Go: POST, json.NewEncoder(w).Encode(formData)
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify(formData)
        });
        if (res.ok) {
            const newUser = await res.json();  // {id:1, name:'Alice', email:'a@test.com'}
            setUsers(prev => [...prev, newUser]);  // Append, immutable (new array ref)
            setFormData({ name: '', email: '' });  // Reset persists
        }
    };

    // Re-render on setUsers: Only list updates (granular)
    return (
        <div>
            <form onSubmit={addUser}>
                <input value={formData.name} onChange={handleInput('name')} placeholder="Name" />
                <input value={formData.email} onChange={handleInput('email')} placeholder="Email" />
                <button type="submit">Add</button>
            </form>
            <ul>
                {users.map(user => <li key={user.id}>{user.name} ({user.email})</li>)}  // Renders persisted
            </ul>
        </div>
    );
}

Var equiv: let formData = {name:'', email:''} — resets on re-render (inputs lose value). useState: Inputs controlled (value=), data persists, list grows.

Когда var vs. useState:

Var (let/const): Stateless computations (const total = a + b;), pure/derived from props (no persistence: const display = props.name.toUpper()). useMemo для expensive/cached (useMemo(() => heavyFilter(data), [data])).
useState: Interactive/persistent (user input, API results, toggles). Complex reducers — useReducer (dispatch actions). Global — useContext + useState. No state — pure components (fast, no hooks).

Perf, Best Practices и Pitfalls:

Granularity: Multiple useState (name, email, loading) — re-renders only affected (vs. one big obj).
Immutability: New refs always (set(prev => [...prev, item])), mutate — no diff trigger (shallow check). Libs: Immer (produce(state, draft => { draft.arr.push(item); return draft; }) → new state).
Updater Functions: set(v => transform(v)) — safe for derived/stale-proof (e.g., async).
Lazy Initial: useState(() => { return fetchInitialFromGo('/api/init'); }) — compute once (not re-run).
Testing: @testing-library/react: userEvent.type(input, 'test') → expect(getByDisplayValue('test')). State persists in virtual DOM.
With Go: useState for res.data (setPosts(posts) — immutable), re-render <PostList posts={posts} /> (targeted, no full app reset). Var — lose API data on any update.
Pitfalls: Set same value (setCount(old) — no re-render, good). Nested objects: Shallow diff (mutate deep — no detect; use immer). Over-nest: useReducer.

useState — enabler reactive persistence, без которого React — static. В Go+React: Holds dynamic data (users from /api/users), driving UI без var resets. Prep: Convert var form to useState — observe input retention.

Вопрос 25. Как управлять срабатыванием useEffect через зависимости и когда оно выполняется без них или с пустым массивом?

Таймкод: 00:24:44

Ответ собеседника: правильный. Без зависимостей - после каждого рендера; с пустым массивом - один раз после первого рендера; с зависимостями - при их изменении.

Правильный ответ:
useEffect — это hook для управления side-effects (API-запросы, подписки, таймеры, манипуляции DOM), который позволяет выполнять код после рендера (post-paint, в асинхронной microtask-очереди, не блокируя UI). Управление срабатыванием происходит через массив зависимостей (deps), где React выполняет shallow-сравнение (===) элементов массива с предыдущими значениями: если любой элемент изменился (примитивы по значению, объекты/функции по ссылке), эффект re-run (сначала cleanup, если есть, затем новый callback). Без deps эффект запускается после каждого рендера (риск infinite loop при setState внутри). С пустым [] — только после первого рендера (mount), cleanup на unmount (аналог componentDidMount + componentWillUnmount). С deps [id, user] — на mount + при изменении любого (e.g., id !== oldId). Deps должны включать все используемые в callback (ESLint exhaustive-deps проверяет, предотвращая stale closures). Cleanup (return fn) — для освобождения ресурсов (abort fetch, clearInterval), runs перед re-run или unmount. В production deps обеспечивают perf (no thrash на unrelated changes), cleanup — предотвращает leaks (memory, network). Для Go-backend: useEffect([query], () => fetch(/api/search?q=${query})) — re-run только на query change, abort old для no races. Pitfalls: Stale deps (old values в closure — fix updater или full deps), empty [] abuse (missed updates). Senior-практика: Custom hooks (useFetch с deps), AbortController, и testing (waitFor для async). useEffect — lifecycle для functional, deps — throttle для efficiency.

Timing и механика deps:
useEffect всегда runs after render (browser paint complete, non-blocking). React tracks effects по order (top-level calls), compares deps shallow (arrays/objects — ref, primitives — value). Initial run — always (no previous deps). Re-run: Cleanup old → run new.

Без зависимостей (useEffect(callback)):
Запускается после каждого рендера (initial + re-renders от state/props/parent/context). Cleanup runs перед каждым re-run + unmount. Полезно для sync post-render (e.g., logging), но опасно: Если effect sets state — infinite loop (render → effect → set → render).
Пример (logging, safe):

import React, { useState, useEffect } from 'react';

function Logger() {
    const [name, setName] = useState('Alice');

    useEffect(() => {
        console.log(`Rendered with name: ${name}`);  // Runs every render
    });  // No deps

    return <button onClick={() => setName('Bob')}>Change Name</button>;
}

Click: setName → re-render → log. No loop (no setState in effect).

Bad infinite (avoid):

function Bad() {
    const [count, setCount] = useState(0);

    useEffect(() => {
        setCount(c => c + 1);  // Runs every → loop crash!
    });

    return <div>{count}</div>;
}

С пустым массивом (useEffect(callback, [])):
Запускается только после первого рендера (initial mount), no re-runs на state/props changes. Cleanup только на unmount. Идеально для one-time init (fetch initial data, set timers, add global listeners).
Пример (init API call to Go):

function App() {
    const [config, setConfig] = useState(null);

    useEffect(() => {
        fetch('/api/config')  // Go: Initial /api/config
            .then(res => res.json())
            .then(setConfig);

        const timer = setInterval(() => console.log('Heartbeat'), 5000);  // One-time setup

        return () => {
            clearInterval(timer);  // Cleanup only on unmount
            console.log('App unmounted');
        };
    }, []);  // Mount only

    return config ? <div>Config loaded: {config.version}</div> : 'Loading...';
}

State change (e.g., user login) → re-render, but no re-fetch/timer reset. Unmount (route change) → cleanup.

С зависимостями (useEffect(callback, [dep1, dep2])):
Запускается после первого рендера (mount), затем re-run если любой dep !== previous (shallow: numbers/strings === value, objects/funcs === ref). Cleanup перед re-run + unmount. Deps — все variables из scope в callback (e.g., [userId, query]).
Пример (fetch on prop change):

function SearchResults({ query }) {  // Prop dep
    const [results, setResults] = useState([]);

    useEffect(() => {
        if (!query) {
            setResults([]);
            return;
        }

        let controller = new AbortController();  // For cleanup

        fetch(`/api/search?q=${query}`, { signal: controller.signal })  // Go: /api/search?q=term
            .then(res => res.json())
            .then(setResults)
            .catch(err => {
                if (err.name !== 'AbortError') console.error('Search failed:', err);
            });

        return () => controller.abort();  // Cleanup on unmount/query change (abort old request)
    }, [query]);  // Re-run if query !== oldQuery

    return (
        <ul>
            {results.map(item => <li key={item.id}>{item.title}</li>)}
        </ul>
    );
}

Query change (input) → abort old fetch + new. Other props (theme) — no effect.

Cleanup Function:
Return () => {} — runs immediately перед следующим effect или unmount. Essential для async/resources: Abort requests (no hanging fetches), clear timers (no leaks), remove listeners (e.g., window.removeEventListener). Runs even if effect skipped (deps same).
Пример с deps и cleanup:

function TimerDisplay({ interval = 1000 }) {
    const [time, setTime] = useState(Date.now());

    useEffect(() => {
        const id = setInterval(() => {
            setTime(Date.now());
        }, interval);

        return () => clearInterval(id);  // Cleanup on unmount/interval change
    }, [interval]);  // Re-run if interval changes (e.g., 1000 → 500)

    return <div>Current time: {new Date(time).toLocaleTimeString()}</div>;
}

Interval change → cleanup old + new interval.

Управление и Best Practices:

Выбор Deps: Minimal (only used vars). Primitives ok, objects/funcs — stable (useMemo/useCallback). Missing — stale (old values: use updater set(v => transform(v)) или add deps).
ESLint: react-hooks/exhaustive-deps — auto-fix missing.
No Deps Use: Rare (logs, always-run). Prefer deps для control.
Empty [] Pitfalls: Static (no react to changes: [] fetch on prop — never updates). Use [prop] для dynamic.

Testing: @testing-library/react:

test('fetches on mount', async () => {
    render(<Comp />);
    await waitFor(() => expect(fetch).toHaveBeenCalledWith('/api'));
});
test('re-fetches on prop change', async () => {
    const { rerender } = render(<Comp query="a" />);
    rerender(<Comp query="b" />);
    await waitFor(() => expect(fetch).toHaveBeenCalledWith('/api/search?q=b'));
});

Cleanup: unmountComponentAtNode для check.

With Go: useEffect([userId], () => fetch(/api/user/${userId})) — one call per id, abort on route change (no zombie requests).
Advanced: useLayoutEffect (sync pre-paint: measure DOM). Custom useEffect wrappers (useAsyncEffect для promises). Concurrent (18+): useEffect non-blocking, but deps same.

Deps — точный контроль lifecycle, без — every, [] — init only. В Go+React: Throttle API (deps on params), cleanup для robust (no leaks on navigation). Prep: Add/remove deps — observe console/network tab.

Вопрос 26. Как вы использовал Redux и для чего он нужен?

Таймкод: 00:25:31

Ответ собеседника: правильный. В паре проектов; для глобального управления состоянием, избежания props drilling, создания общего хранилища.

Правильный ответ:
Я использовал Redux в нескольких проектах на React, включая admin-панели для SaaS-приложений и e-commerce платформы, где он решал задачи centralized state management для сложных сценариев: аутентификация пользователей, корзина покупок, реал-тайм обновления данных из API и обработка форм с валидацией. В одном проекте (dashboard для мониторинга) Redux управлял состоянием метрик (fetch из Go-backend каждые 30с), с optimistic updates (UI обновляется до подтверждения сервера) и rollback на ошибки. В другом (онлайн-магазин) — для cart (добавление/удаление товаров, persist в localStorage) и auth (JWT tokens, protected routes). Использовал Redux Toolkit (RTK) для минимизации boilerplate (createSlice для reducers/actions, RTK Query для API endpoints), thunk для async (fetch/post to Go), и DevTools для debugging (action history, state diffs). Нужен Redux для predictable unidirectional flow: actions (events) → reducers (pure updates) → store (single immutable tree) → views (re-render via selectors). Это устраняет prop drilling (pass data через 5+ уровней), обеспечивает consistency (global state как auth/token доступен везде), и упрощает async (middleware для API, websockets). В production: Testable (pure reducers), performant (selectors memoize computes), scalable (slices per feature). Для Go-backend: Redux держит JSON responses (dispatch(fetchSuccess(res.json()))), enabling reactive UI (state → re-render list без reloads). Без Redux — local useState/Context fine для small, но large apps (100+ components) — chaos (duplicate fetches, inconsistent auth). Alternatives: Zustand (minimal), Context + useReducer (built-in), MobX (observable). RTK + RTK Query — мой go-to (auto-caching, hooks для queries/mutations).

Redux — library (не фреймворк), Flux-inspired (Facebook), с single store (JS object). Flow: UI dispatch actions → middleware (async) → reducers (immutable updates) → notify components (useSelector). Immutability enforced (return new state, no mutate).

Core Components и Usage in Projects

Store: Single source (configureStore(RTK), combineReducers). Holds slices (user: {auth, list}, cart: {items}).
Actions: Plain objects (type, payload). Async — thunks (return (dispatch) => { fetch... dispatch(success) }).
Reducers: Pure (state, action) → newState. RTK: createSlice (auto-actions, immer mutable code).
Selectors: Get slice/computes (useSelector(state => state.user.list), reselect memo).
Middleware: Thunk (promises), saga (generators), logger.

Пример RTK Slice (users, Go API):

// features/users/userSlice.js
import { createSlice, createAsyncThunk, createEntityAdapter } from '@reduxjs/toolkit';

const usersAdapter = createEntityAdapter();  // Normalized state (ids, entities)

export const fetchUsers = createAsyncThunk('users/fetch', async () => {
    const res = await fetch('/api/users');  // Go: http.HandleFunc("/api/users", getUsers)
    if (!res.ok) throw new Error('Fetch failed');
    return res.json();  // [{id:1, name:'Alice'}, ...]
});

export const addUser = createAsyncThunk('users/add', async (newUser) => {
    const res = await fetch('/api/users', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(newUser)
    });
    return res.json();  // {id:2, name:'Bob', ...}
});

const userSlice = createSlice({
    name: 'users',
    initialState: usersAdapter.getInitialState({ loading: false, error: null }),
    reducers: {
        clearError: (state) => { state.error = null; },
    },
    extraReducers: (builder) => {
        builder
            .addCase(fetchUsers.pending, (state) => { state.loading = true; state.error = null; })
            .addCase(fetchUsers.fulfilled, (state, action) => {
                state.loading = false;
                usersAdapter.setAll(state, action.payload);  // Normalized
            })
            .addCase(fetchUsers.rejected, (state, action) => {
                state.loading = false;
                state.error = action.error.message;
            })
            .addCase(addUser.fulfilled, (state, action) => {
                usersAdapter.addOne(state, action.payload);  // Optimistic possible
            });
    },
});

export const { clearError } = userSlice.actions;
export default userSlice.reducer;

// store.js
import { configureStore } from '@reduxjs/toolkit';
import { userApi } from '../api/userApi';  // RTK Query optional
import userReducer from './features/users/userSlice';

export const store = configureStore({
    reducer: {
        users: userReducer,
        [userApi.reducerPath]: userApi.reducer,  // If Query
    },
    middleware: (getDefaultMiddleware) =>
        getDefaultMiddleware().concat(userApi.middleware),  // Thunk + Query
});

Normalized (adapter): State { ids: [1,2], entities: {1: {name:'Alice'}} } — efficient updates (addOne O(1)).

Component Usage (Hooks):

import { useSelector, useDispatch } from 'react-redux';
import { fetchUsers, clearError } from './features/users/userSlice';
import { useEffect } from 'react';

function UserList() {
    const dispatch = useDispatch();
    const { ids, entities, loading, error } = useSelector(state => state.users);  // Select normalized
    const users = ids.map(id => entities[id]);  // Computed

    useEffect(() => {
        dispatch(fetchUsers());  // Async thunk
    }, [dispatch]);

    if (loading) return <div>Loading...</div>;
    if (error) return <div>Error: {error} <button onClick={() => dispatch(clearError())}>Clear</button></div>;

    return (
        <ul>
            {users.map(user => (
                <li key={user.id}>{user.name}</li>
            ))}
        </ul>
    );
}

// With RTK Query (auto-fetch)
import { userApi } from '../api/userApi';

function UserListQuery() {
    const { data, isLoading, error } = userApi.useGetUsersQuery();  // Auto-dispatch, cache
    if (isLoading) return <div>Loading...</div>;
    return (
        <ul>
            {data?.map(user => <li key={user.id}>{user.name}</li>)}
        </ul>
    );
}

useSelector subscribes (re-render on slice change), Query — hooks (auto-refetch on focus, invalidateTags).

Async в Redux (Thunk/RTK Query):
В проектах: Thunk для custom (e.g., login: dispatch(loginStart()); fetch('/api/login').then(dispatch(loginSuccess(token))). В RTK Query — declarative (useMutation для POST to Go, auto-loading/error). Optimistic: dispatch(addOptimistic(user)); try { await post } catch { dispatch(rollback) }. Go: Handlers (e.g., mux.HandleFunc("/api/users", createUser) — json.Decode, db.Insert, json.Encode).

Benefits in My Projects:

No Drilling: User state (useSelector) в deep components (e.g., <Header> <UserAvatar user={...} /> — no pass).
Consistency: Auth loading/error global (one reducer).
Debug: DevTools replay (login fail → see action/error).
Testing: Reducer: expect(userReducer(state, fetchSuccess(data))).toEqual({users: data}). Store: <Provider store={mockStore}><Comp /></Provider>.
Go Integration: Actions dispatch API (fetch → Go mux → JSON → reducer). RTK Query caches (no duplicate /api/users).

Trade-offs:

Boilerplate: RTK cuts 80% (no manual types/actions).
Overkill: <3 globals — Context/useReducer.
Learning: Flux principles (actions first).

Redux — для reliable global state в medium-large React apps, с RTK как standard. В Go+React: Unified flow (Go state → JSON → Redux → UI). Prep: RTK boilerplate app, dispatch — observe DevTools.

Вопрос 27. Как в компоненте получить данные из Redux state без передачи через props?

Таймкод: 00:26:34

Ответ собеседника: правильный. Через useSelector с селектором-колбэком, который извлекает нужные поля из state.

Правильный ответ:
В React-компоненте получение данных из Redux state без prop drilling (передачи через родителей) происходит через hook useSelector из @reduxjs/toolkit (или react-redux), который подписывает компонент на изменения store slice и re-renders только при update relevant data (shallow equality check селектора result). useSelector(selectorFn) — selectorFn (state, ownProps) extracts slice или computed (e.g., state.user.name), returning value. Если result !== previous (=== shallow), re-render. Для perf: Memoized selectors (reselect createSelector) compute only on deps change, avoid deep copies. Alternatives: connect(mapStateToProps) для class/legacy, useStore().getState() (manual, no sub). В production: useSelector для granular (e.g., select user in <Profile>, list in <Users>), combined с useDispatch для actions. Для Go-backend: useSelector(state => state.api.users) — holds JSON from /api/users, enabling direct access (no pass from <App>). Pitfalls: Selector returns new obj each time (e.g., { ...state.user } — always re-render); fix shallow or memo. Multiple selectors — one useSelector (combine). Senior-практика: RTK selectors (userSelectors.selectUserById), DevTools (inspect state/sub), и testing (Provider + useSelector mock). useSelector — bridge store to UI, declarative (select what need, auto-update).

useSelector: Механика и Использование
useSelector subscribes component to store (connect-like), runs selector on every store update (dispatch), but skips re-render if result stable. Selector — pure fn, top-level (no side-effects). OwnProps — if need (e.g., select by prop id).

Basic: const user = useSelector(state => state.user);
Computed: const fullName = useSelector(state => ${state.user.first} ${state.user.last});
Nested: const items = useSelector(state => state.cart.items);

Пример базового (global user без props):

// Component
import React from 'react';
import { useSelector } from 'react-redux';

function UserProfile() {
    // Direct access to state.user, no props from parent
    const user = useSelector(state => state.user);  // { name: 'Alice', email: 'a@test

#### **Вопрос 28**. Для чего нужен TypeScript?

**Таймкод:** <YouTubeSeekTo id="biJpW1B1qng" time="00:27:23"/>

**Ответ собеседника:** **правильный**. Для строгой типизации, предотвращения ошибок в больших проектах, автодополнения и выявления ошибок на этапе разработки.

**Правильный ответ:**  
TypeScript (TS) — это superset JavaScript, разработанный Microsoft (2012), который добавляет optional static typing, interfaces, generics и advanced features (enums, tuples, mapped types), компилирующийся в plain JS для any runtime (browsers, Node). Нужен TS для type safety на compile-time, предотвращая runtime errors (e.g., undefined.prop crash), улучшая developer experience (DX: intellisense, refactoring, navigation в IDE как VS Code), и обеспечивая scalability в large projects/teams (100k+ LOC, multiple devs — shared contracts via types). Без TS JS dynamic typing leads to subtle bugs (e.g., string as number → NaN), hard debugging в production (console logs, any casts). TS catches 70-90% errors pre-runtime (studies: Microsoft, Airbnb), accelerates onboarding (docs in types), и boosts perf (optimized code via type hints, e.g., V8 JIT). В React: Typed props/state (interface Props \{ name: string; \}) — auto-checks, no propTypes boilerplate. Для Go-backend: TS types mirror Go structs (e.g., User \{id: number, name: string\} → Go struct User \{ID int; Name string\}), shared via OpenAPI/Swagger (generated .d.ts), reducing API mismatches (fetch res.json() as User[]). SQL: Typed queries (e.g., prisma with TS — select&lt;User[]&gt;). В production: Strict mode (noImplicitAny), generics for utils (fetch&lt;T&gt;(url): Promise&lt;T&gt;), и TSConfig (lib: es2020, target: es5). Pitfalls: Over-typing (verbose), migration (gradual: .ts/.tsx), runtime no-checks (use type guards). Senior-практика: Utility types (Partial&lt;User&gt;, Omit), branded types (safety), и tools (ts-reset для common patterns). TS — enabler robust, maintainable codebases, от prototypes к enterprise (e.g., VS Code itself in TS).

TS transpiles (tsc/esbuild) to JS, no runtime overhead (erased types), but .d.ts for libs (npm @types). Config: tsconfig.json (strict: true для rigor).

**Основные преимущества TS:**  
1. **Type Safety и Error Prevention**: Static analysis catches mismatches (e.g., func(number) called with string — compile error). Union types (string | number), literals (type Status = &#39;loading&#39; | &#39;error&#39;), guards (if (typeof x === &#39;string&#39;)). Reduces bugs 15-20% (State of JS surveys).  
   *Пример (React prop error prevention):*  
   ```typescript
   // User.tsx
   interface User {
       id: number;
       name: string;
       email: string;
   }

   interface UserListProps {
       users: User[];  // Typed array
       onSelect: (user: User) => void;  // Func sig
       loading?: boolean;  // Optional
   }

   const UserList: React.FC<UserListProps> = ({ users, onSelect, loading = false }) => {
       if (loading) return <div>Loading...</div>;

       return (
           <ul>
               {users.map(user => (  // TS checks user.name exists
                   <li key={user.id} onClick={() => onSelect(user)}>
                       {user.name} ({user.email})
                   </li>
               ))}
           </ul>
       );
   };

   // Usage
   const App = () => {
       const [selected, setSelected] = useState<User | null>(null);
       const users: User[] = [{ id: 1, name: 'Alice', email: 'a@test.com' }];  // Typed

       // Error if wrong type: onSelect={(u: string) => ...} — TS error
       return <UserList users={users} onSelect={setSelected} />;
   };

TS: No runtime check, but compile fail on mismatch (e.g., users.push('invalid') — error). JS: Runtime crash.

Developer Experience (DX): IntelliSense (VS Code: auto-complete User.name), refactoring (rename → all usages), navigation (go to definition). Hover types, errors inline. Faster coding 20-30% (team velocity).
Пример (API fetch with types):

// api.ts
interface ApiResponse<T> {
    data: T;
    status: number;
    error?: string;
}

const fetchUsers = async (): Promise<ApiResponse<User[]>> => {
    const res = await fetch('/api/users');  // Go: returns JSON {data: [...], status: 200}
    if (!res.ok) throw new Error('Failed');
    return res.json();  // TS infers ApiResponse<User[]>
};

// Component
const Users = () => {
    const [users, setUsers] = useState<User[]>([]);  // Typed state
    const [loading, setLoading] = useState(false);

    useEffect(() => {
        setLoading(true);
        fetchUsers()
            .then(({ data }) => setUsers(data))  // data: User[] — auto-complete data[0].name
            .catch(err => console.error(err))
            .finally(() => setLoading(false));
    }, []);

    return <div>{users[0]?.name}</div>;  // ?. safe (TS knows optional)
};

IDE: Hover fetchUsers → Promise<ApiResponse<User[]>>, error if setUsers(string).

Scalability и Team Collaboration: Interfaces/contracts (e.g., API shapes from Go OpenAPI: generated User.d.ts), generics (Reusable<T>: fetch<T>(url)). Enforces consistency (no any abuse). Large codebases (Angular/React enterprise) — 50% less bugs.
Пример (Go + TS shared types via OpenAPI):
Go struct (backend):

type User struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Email string `json:"email"`
}

// /api/users handler
func getUsers(w http.ResponseWriter, r *http.Request) {
    users := []User{{1, "Alice", "a@test.com"}}
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(users)  // JSON array
}

TS (frontend, generated from Swagger):

// user.ts (openapi-typescript generate)
export interface User {
    id: number;
    name: string;
    email: string;
}

export type UsersResponse = User[];  // Matches Go JSON

// Use in fetch
const res = await fetch('/api/users');
const users: UsersResponse = await res.json();  // TS validates shape
// Error if extra field: {id:1, name:'Alice', invalid:'foo'} — compile warn

Shared: Go + swagger-codegen-ts → .d.ts, no mismatch (e.g., Go int → TS number).

Advanced Features: Generics (function<T>(arg: T): T), utility types (Partial<User>, Pick<User, 'name' | 'email'>), modules (declare module 'lib'). TS-in-JS (allowJs: true) для gradual adoption.
Пример generics (utility):

function fetchResource<T>(url: string): Promise<T> {
    return fetch(url).then(res => res.json() as T);  // Cast to T
}

// Use
const users = await fetchResource<User[]>('/api/users');  // users: User[]
const config = await fetchResource<{version: string}>('/api/config');  // Typed

SQL (e.g., Prisma TS):

const users = await prisma.user.findMany({ where: { active: true } });  // users: User[]
// TS checks fields (no undefined.name)

Integration with React и Best Practices:

React: @types/react, FC<Props>, useState<T>(initial: T). Hooks: useEffect<void, [deps: string[]]>. Strict generics (useState<User | null>(null)).
Config: tsconfig.json: "strict": true (noImplicitAny, strictNullChecks), "jsx": "react-jsx" (auto-import). ESLint + typescript-eslint.
Migration: Start .js + // @ts-check, then .ts.
Testing: Jest + ts-jest (typed mocks: jest.fn<(id: number) => void>()).
With Go: Protobuf/JSON schemas → TS types (protoc-gen-ts). API: Axios with typed res (axios.get<User[]>('/api')). No more res.data.foo undefined.
Pitfalls: Any overuse (void it), over-spec (verbose unions), runtime no-enforce (use runtime validators like Zod: z.object({name: z.string()}).parse(data)).
Perf: TS slower compile (~20%), but esbuild/SWC fast (Vite/Next.js).

TS — investment в reliability (fewer prod crashes), DX (faster dev), и collaboration (typed contracts). В full-stack Go+React: Shared types (Go struct → TS interface) — zero-mismatch APIs, scalable от MVP к enterprise. Prep: Convert JS component to TS — see errors vanish.

Вопрос 29. Какую роль играет TypeScript для бизнеса после деплоя проекта?

Таймкод: 00:28:00

Ответ собеседника: неполный. Особой роли нет, так как компилируется в JavaScript.

Правильный ответ:
После деплоя проекта TypeScript (TS) не влияет на runtime (transpiles to plain JS, no overhead), но играет ключевую роль в business value через long-term maintainability, cost efficiency и scalability: Снижает technical debt (easier refactoring, fewer regressions), ускоряет onboarding (typed docs как self-documentation), минимизирует downtime (compile-time checks prevent prod bugs, e.g., type mismatches in API calls), и enables faster iterations (devs spend less time debugging, more on features). В large-scale apps (e.g., 500k+ LOC, 50+ devs) TS cuts maintenance costs 20-40% (studies: Google, Microsoft), ensuring compliance (typed contracts with backend like Go — no data corruption from JSON mismatches) и reliability (strict mode catches nulls/undefined pre-deploy). Для бизнеса: Reduced support tickets (stable UX, no crashes on edge cases), quicker feature rollouts (refactor without fear), и ROI growth (invest upfront → save post-deploy). Без TS JS projects suffer silent failures (runtime errors from any/undefined), leading to hotfixes, lost revenue (downtime), и churn (dev frustration). В Go+React: TS types mirror Go structs (e.g., User interface → Go User struct), preventing deserialization errors (json.Unmarshal fails silently in JS), ensuring API stability (OpenAPI-generated types). Post-deploy: TS facilitates audits (type coverage), migrations (e.g., API v2 — update types, catch breaks), и monitoring (typed logs/errors). Senior-практика: CI/CD with tsc checks (fail on type errors), gradual typing (JSDoc @types), и metrics (bug reduction via Sentry typed errors). TS — strategic asset, shifting costs from ops/debug to innovation.

Runtime vs. Post-Deploy Impact:
TS erases to JS (tsc: types removed, generics inlined), so prod bundle same size/speed (esbuild fast compile). Но value в development lifecycle: Pre-deploy safety translates to post-deploy stability. Business metrics: Lower MTTR (mean time to resolution — typed stacks in errors), higher velocity (refactor 2x faster with rename-all), и compliance (typed APIs reduce integration failures with Go services).

Пример (React + Go API, TS prevents post-deploy bugs):
Go backend (stable JSON):

type User struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Email string `json:"email"`
}

func getUser(w http.ResponseWriter, r *http.Request) {
    user := User{ID: 1, Name: "Alice", Email: "alice@example.com"}
    json.NewEncoder(w).Encode(user)  // {"id":1,"name":"Alice","email":"alice@example.com"}
}

JS without TS (risky):

// JS: No checks, runtime crash possible
async function fetchUser() {
    const res = await fetch('/api/user');
    const user = res.json();  // Could be {id:1, name:123, email:undefined} — bad data
    console.log(user.namme);  // Typo: undefined, silent fail
    return user;  // Pass bad data to UI
}

TS (catches at compile/deploy):

// user.ts (typed contract)
export interface User {
    id: number;
    name: string;
    email: string;
}

async function fetchUser(): Promise<User> {  // Enforces return type
    const res = await fetch('/api/user');
    if (!res.ok) throw new Error('Failed');
    const data = await res.json();  // data: any, but cast
    const user = data as User;  // Or zod.parse(data) for runtime
    // Compile error: if data = {id:1, name:123} — name number ≠ string
    // Typo: user.namme — TS error: Property 'namme' does not exist
    return user;
}

// Component
function Profile() {
    const [user, setUser] = useState<User | null>(null);  // Typed state

    useEffect(() => {
        fetchUser().then(setUser).catch(console.error);  // setUser expects User
    }, []);

    return user ? <div>{user.name} ({user.email})</div> : 'Loading';  // TS knows user.name string
}

Post-deploy: Go changes Email to optional — update TS interface, CI fails on mismatch (tsc error), no prod bug (e.g., undefined.email crash). JS: Deploy blind, users see broken UI.

Business Benefits Post-Deploy:

Cost Savings: Fewer bugs = less dev time (debugging 30% effort in JS vs. 10% TS), reduced ops (no emergency deploys). Example: E-commerce — typed cart prevents order loss (CartItem {quantity: number} — no 'abc' qty).
Reliability/UX: Compile errors catch 80% issues (null checks with ? or !), stable integrations (Go JSON → TS User — no parse fails). Downtime down 50% (typed error stacks).
Scalability/Onboarding: Types as docs (hover interface — API shape), refactoring safe (VS Code rename across files). New devs ramp 2x faster (auto-complete Go API fields). Large teams: Typed PRs (no merge bad types).
Compliance/Audit: Typed contracts (Go + TS = verified schemas), easier audits (type coverage reports). Regulated (fintech): Types enforce data integrity (User.age > 18).
Velocity/ROI: Post-MVP: Add features without regression (types guide), migrate (e.g., API v2 — update types, find all usages). Business: Faster A/B tests, new markets (typed i18n).

Пример shared types (Go + TS via OpenAPI):
Swagger/OpenAPI (from Go):

components:
  schemas:
    User:
      type: object
      properties:
        id: { type: integer }
        name: { type: string }
        email: { type: string }

Generated TS (.d.ts):

export interface User {
    id: number;
    name: string;
    email: string;
}

Post-deploy: Go adds field (optional) — regenerate TS, deploy frontend update. No mismatch (e.g., Go sends extra — TS ignores, or error if required).

Implementation и Best Practices:

CI/CD: tsc --noEmit (check types without compile), fail builds on errors (GitHub Actions: yarn tsc).
Gradual: jsconfig.json + @ts-check for legacy JS.
Runtime Validation: TS compile-only; pair with Zod/Yup (z.object(User).parse(data) — runtime safe).
Go Integration: Use swaggo/swag for Go docs → OpenAPI → openapi-typescript-codegen (TS types). Protobuf: protoc --ts_out for shared .proto.
Metrics: Track bug rates pre/post-TS (Sentry: typed errors easier filter). Teams: Enforce noImplicitAny in tsconfig.
Trade-offs: Compile time (mitigate SWC/esbuild), verbosity (utilities: type SafeUser = User & { safe: true }).

TS post-deploy — invisible guardian: Enables business growth via reliable, efficient code evolution, not just dev tool. В Go+React: Typed APIs = seamless full-stack, fewer incidents (no deserial fail). Prep: Add TS to JS fetch — see compile catches.

Вопрос 30. Какие основные типы данных есть в TypeScript?

Таймкод: 00:28:19

Ответ собеседника: неполный. number, string, undefined, null, object, any, void.

Правильный ответ:
В TypeScript (TS) типы данных — это система static typing, расширяющая JS primitives, с structural typing (types compatible if shapes match) и advanced constructs (unions, intersections, generics). Основные — primitive (number, string, boolean, null, undefined, symbol, bigint), object-based (object, array, tuple, enum), special (any, unknown, void, never), и utility (literals, unions). TS infers types (e.g., let x = 5 → number), explicit annotations (let x: number = 5), и type guards (if (typeof x === 'string')). Purpose: Safety (compile errors on mismatch), DX (auto-complete), и expressiveness (e.g., User | null for optional). Compared to JS (dynamic any), TS reduces errors 50%+ (inferred or explicit). В React: Props { name: string }, state User[]. Для Go-backend: Types match JSON (number for Go int, string for Go string), preventing parse fails (e.g., fetch res.json() as User[]). Advanced: Generics (Array<T>), mapped (Record<string, number>). Pitfalls: Any (bypass, avoid), implicit any (strict mode errors). Senior-практика: Narrowing (type guards), branded (type Brand = string & { __brand: 'id' }), и tools (ts-toolbelt for utils). TS types — foundation type-safe code, scalable от simple vars to complex APIs.

Primitive Types (Базовые):
Primitives — immutable, inferred from literals.

number: Numeric (int/float, 64-bit float). No separate int/bool (bool → number in JS).

let age: number = 30;  // Infer: const age = 30;
let pi: number = 3.14;
// Error: age = '30' — string ≠ number

string: Text (UTF-16). Literals ('hello'), template ${name}.

let name: string = 'Alice';
let greeting: string = `Hello, ${name}`;  // Inferred

boolean: True/false.

let isActive: boolean = true;
// Error: isActive = 1 — number ≠ boolean

null: Intentional absence (nullable).

let user: User | null = null;  // Optional user

undefined: Default absence (uninitialized).

let temp: string | undefined;  // Not assigned

symbol: Unique keys (private props).

const sym = Symbol('key');
let obj = { [sym]: 'value' };

bigint: Large integers (n suffix).
```
let big: bigint = 123n;
```

Object Types (Структурные):

object: Non-primitive (arrays, functions, {} ). Generic Object.

let data: object = { name: 'Alice' };  // Loose, prefer interfaces

array: Typed lists (T[]).

let users: User[] = [{ id: 1, name: 'Alice' }];
let numbers: number[] = [1, 2, 3];
let mixed: (string | number)[] = ['a', 1];  // Union array
// Readonly: readonly User[]

tuple: Fixed-length, typed positions ( [string, number] ).

let pair: [string, number] = ['Alice', 30];  // pair[0]: string, pair[1]: number
// Error: pair = [30, 'Alice'] — positions mismatch

enum: Named constants (numeric/string).

enum Status {
    Loading,  // 0
    Success = 1,
    Error,
}
let state: Status = Status.Loading;  // 0
// String enum
enum Color {
    Red = 'RED',
    Green = 'GREEN',
}

function: Signatures ( (arg: T) => R ).

let add: (a: number, b: number) => number = (a, b) => a + b;
// Error: add('1', 2) — string ≠ number

Special Types (Специальные):

any: Bypass checks (JS-like, avoid — loses safety).

let x: any = 5;
x = 'hello'; x.foo();  // No error, but runtime crash possible

unknown: Safe any (must narrow before use).

let y: unknown = 'hello';
if (typeof y === 'string') y.toUpperCase();  // Safe
// Error: y.toUpperCase() — unknown no methods

void: No return (functions).

function log(msg: string): void {
    console.log(msg);
}

never: Impossible (errors, infinite loops).

function fail(): never {
    throw new Error('Failed');
}
// Exhaustive unions: function handle(status: Status) { switch... default: const _exhaustive: never = status; }

Composite Types (Составные):

union: Or (T | U).

let id: string | number = 'abc'; id = 123;  // Flexible
function print(id: string | number) {
    if (typeof id === 'string') console.log(id.toUpperCase());  // Narrowing
}

intersection: And (T & U).

type Admin = User & { role: 'admin' };
let admin: Admin = { id: 1, name: 'Alice', role: 'admin' };

literal: Specific values ( 'loading' | 'error' ).

type Status = 'loading' | 'success' | 'error';
let s: Status = 'loading';  // Error: s = 'unknown'

Record/Keyof: Maps (Record<string, number>), keys (keyof User = 'id' | 'name').

React/Go Examples:
React (typed props):

interface Props {
    user: User;
    onUpdate: (updates: Partial<User>) => void;  // Utility Partial
}
const Component: React.FC<Props> = ({ user, onUpdate }) => (
    <button onClick={() => onUpdate({ name: user.name.toUpperCase() })}>Update</button>
);

Go integration (typed fetch):

interface ApiUser extends User {  // Extend for API
    createdAt: Date;  // Go time.Time → JS Date
}
const users = await fetch<User[]>('/api/users');  // Infer array
// TS: users[0].id number, error on users[0].invalid

SQL (typed ORM):

// Prisma schema → TS
const activeUsers = await prisma.user.findMany({ where: { active: true } });  // User[]

Best Practices:

Infer when possible (let x = 5 → number), explicit for clarity (let x: number = 5).
StrictNullChecks: true — force ? or !.
Avoid any/unknown first, narrow (type predicates).
Generics: <T> for reusable (function identity<T>(arg: T): T).
With Go: Use io-ts or Zod for runtime + compile.

TS types — toolkit safety, от primitives to complex (unions/generics). Prep: Annotate JS var — see inferences/errors.

Вопрос 30. Что такое generics в TypeScript?

Таймкод: 00:29:01

Ответ собеседника: правильный. Для обобщения типов, когда тип параметра неизвестен заранее; используются в угловых скобках для контроля входных/выходных типов.

Правильный ответ:
Generics в TypeScript — это механизм parametric polymorphism, позволяющий создавать reusable, type-safe структуры (functions, classes, interfaces), которые работают с arbitrary types (T, U), без потери compile-time checks или дублирования code (e.g., one Array<T> for number/string вместо separate). Синтаксис: <T> (type parameters в угловых скобках), где T — placeholder (convention: T for Type, K for Key, V for Value). При использовании specify concrete type (Array<number>), TS substitutes, ensuring input/output safety (e.g., push(number) — error on string). Purpose: Abstraction без any (unsafe), enabling scalable utils (fetch<T>, Box<T>), collections (Map<K,V>), и React components (Table<T>). В large projects generics reduce boilerplate 30-50% (typed APIs, utils), prevent errors (mismatch in generic calls). Compared to JS (no types), generics add constraints (extends BaseType), defaults (T = string), и inference (TS guesses T from args). Для Go-backend: Generics mirror Go generics (1.18+), for typed API wrappers (fetch<User>(url): Promise<User>), shared schemas (GenericResponse<T>). В React: Typed hooks (useState<T>), components (Button<P extends Props>). Pitfalls: Over-generalization (complex constraints), inference fails (explicit <T>). Senior-практика: Constraints (T extends {id: number}), multiple params (Pair<K,V>), и tools (ts-toolbelt for advanced). Generics — core TS power, для flexible, safe code от utils to full-stack.

Generics compile to JS (T erased, but checks preserved), no runtime cost, but enable DX (auto-complete T fields).

Basic Syntax и Function Generics:
Function generics: Declare <T> before params/return, use T inside. Inference: TS infers from arg (no explicit).
Пример simple function (identity, reusable):

function identity<T>(arg: T): T {  // T unknown, but preserved
    return arg;
}

// Usage: Inference
const num = identity(42);  // num: number
const str = identity('hello');  // str: string
const user = identity({ name: 'Alice' });  // user: { name: string }

// Explicit (rare, when inference fails)
const arr: number[] = identity<number[]>([1, 2, 3]);

// With constraint (T extends number | string)
function print<T extends number | string>(val: T): T {
    console.log(val);
    return val;
}
// Error: print({});  // {} not number|string
print(42);  // OK, 42: number

Constraint (extends) limits T (safety, e.g., T has .length).

Class и Interface Generics:
Classes/interfaces parameterize members.
Пример class (Box, generic container):

interface Container<T> {  // Interface
    value: T;
    set: (newVal: T) => void;
}

class Box<T> implements Container<T> {
    private _value: T;

    constructor(initial: T) {
        this._value = initial;
    }

    get value(): T { return this._value; }

    set value(newVal: T) {  // Only T allowed
        this._value = newVal;
    }
}

// Usage
const numBox = new Box<number>(42);  // numBox.value: number
numBox.value = 100;  // OK
// numBox.value = 'hello';  // Error: string ≠ number

const userBox = new Box<User>({ id: 1, name: 'Alice' });  // userBox.value: User

Multiple params: <K, V> (e.g., Map<K,V>).

Array, Promise и Built-in Generics:
TS core: Array<T>, Promise<T>, Readonly<T>, Partial<T>.
Пример utility with built-in:

// Generic fetch (Go API)
interface ApiError {
    message: string;
    code: number;
}

interface ApiResponse<T> {
    data: T;
    success: boolean;
    error?: ApiError;
}

async function fetchResource<T>(url: string): Promise<ApiResponse<T>> {
    const res = await fetch(url);
    if (!res.ok) {
        return { success: false, error: { message: 'Failed', code: res.status } };
    }
    const data = await res.json();
    return { success: true, data: data as T };  // Cast to T
}

// Usage
interface User { id: number; name: string; }

const usersRes = await fetchResource<User[]>('/api/users');  // usersRes.data: User[]
if (usersRes.success) {
    const firstUser = usersRes.data[0];  // firstUser.name: string (auto-complete)
    // Error: firstUser.invalid — no such prop
}

// Config
const configRes = await fetchResource<{ version: string }>('/api/config');

Go match: ApiResponse<User[]> → Go json {data: []User, success: true}.

React Integration (Generic Components/Hooks):
Generics for reusable UI/API.
Пример generic table (React + TS):

interface TableProps<T> {
    data: T[];
    keyExtractor: (item: T) => string | number;
    renderItem: (item: T) => React.ReactNode;
}

function DataTable<T>({ data, keyExtractor, renderItem }: TableProps<T>) {
    return (
        <table>
            <tbody>
                {data.map(item => (
                    <tr key={keyExtractor(item)}>
                        {renderItem(item)}
                    </tr>
                ))}
            </tbody>
        </table>
    );
}

// Usage
interface User { id: number; name: string; email: string; }

const users: User[] = [{ id: 1, name: 'Alice', email: 'a@test.com' }];

<DataTable<User>
    data={users}
    keyExtractor={(user: User) => user.id}
    renderItem={(user: User) => (
        <td>{user.name} - {user.email}</td>  // TS knows user.email string
    )}
/>;

// Inferred (if possible)
const numbers = [1, 2, 3];
<DataTable
    data={numbers}
    keyExtractor={(n: number) => n}  // TS infers T=number
    renderItem={(n: number) => <td>{n * 2}</td>}
/>;

Hooks: Custom useApi<T>(url: string): { data: T | null, loading: boolean }.

Advanced Generics:

Defaults: <T = string> (fallback if no specify).

function greet<T = string>(name: T): string {
    return `Hello, ${String(name)}`;
}
greet();  // Error: arg required, but default T=string
greet('Alice');  // OK, T inferred string

Multiple/Constraints: <K extends string, V>(key: K, value: V).
Mapped/Conditional: type Keys<T> = { [K in keyof T]: K }; type NonNullable<T> = T extends null | undefined ? never : T.

Go + TS Generics (Shared):
Go generics (1.18): func Fetch[T any](url string) T. TS equiv: fetch<T>(url): Promise<T>. Shared via protobuf (message User {} → generic service).

Best Practices:

Name: T (single), <Item, Index> (multi).
Constraints: extends для methods (T extends {length: number}).
Inference: Rely, explicit only if ambiguous.
Avoid over (simple — no generics). With Zod: z.generic<T>().parse(data).
Testing: Mock generics (jest.fn<(arg: T) => R>()).

Generics — TS superpower reusability+safety, для utils/components/APIs. В Go+React: Generic fetch<T> — typed Go JSON, no cast errors. Prep: Write identity<T> — use with User, see checks.

Вопрос 31. Что такое интерфейсы в TypeScript?

Таймкод: 00:29:55

Ответ собеседника: правильный. Обобщения для классов, определяют поля и методы для наследования; нельзя создавать экземпляры.

Правильный ответ:
Интерфейсы в TypeScript (interfaces) — это способ определения контрактов (shapes) для объектов, классов и функций, описывающих required structure (properties, methods, signatures) без реализации, обеспечивая type safety на compile-time через structural typing (compatibility по форме, не по имени). Они абстрактны (no instances: нельзя new Interface()), но enforceable (obj must match shape, error on mismatch). Purpose: Reusability (extend/merge), documentation (self-describing APIs), и safety (catch errors early, e.g., missing prop). В отличие от type aliases (unions/intersections), interfaces focused on object shapes, extensible (extends Base), и mergable (declaration merging для ambient). В large apps interfaces define props (React), API responses (Go JSON), configs (modular). TS infers if possible, but explicit for clarity. Без interfaces JS any leads to runtime fails (e.g., obj.foo undefined); interfaces prevent (compile error). Для Go-backend: Interfaces mirror structs (interface User {id: number; name: string} → Go struct User {ID int; Name string}), shared via OpenAPI (generated .d.ts), ensuring JSON parse safety (res.json() as User). В React: Interface Props {children: ReactNode} — typed components. Pitfalls: Over-extension (complex hierarchies), vs. types (use type for primitives/unions). Senior-практика: Optional (? ), readonly, index signatures ([key: string]: value), и combine with generics (Interface<T>). Interfaces — blueprint для scalable, maintainable code, от simple objects to full contracts.

Interfaces compile away (no runtime), but enable IDE DX (auto-complete, errors).

Basic Object Interfaces:
Define properties (required/optional).
Пример simple shape:

interface User {
    id: number;  // Required
    name: string;
    email: string;
    age?: number;  // Optional (?)
}

// Usage
const user: User = { id: 1, name: 'Alice', email: 'a@test.com' };  // OK
// user.age = 30;  // OK, optional

// Error: Missing required
const badUser = { name: 'Bob' };  // Error: Missing id, email

// Error: Extra OK (structural), but wrong type no
const invalid: User = { id: '1', name: 'Alice', email: 123 };  // id: string ≠ number, email: number ≠ string

Functions use: function process(user: User) { console.log(user.name); } — TS knows name string.

Extending и Merging Interfaces:
Extend (inherits + adds), merge (multiple declarations same name).
Пример extension (Admin extends User):

interface User {
    id: number;
    name: string;
    email: string;
}

interface Admin extends User {  // Inherit all + add
    role: 'admin';
    permissions: string[];
}

const admin: Admin = {
    id: 1,
    name: 'Alice',
    email: 'a@test.com',
    role: 'admin',
    permissions: ['read', 'write']
};  // OK, User props + extra

// Usage: Admin assignable to User (structural)
function greet(u: User) { console.log(`Hi, ${u.name}`); }
greet(admin);  // OK, shape matches

Merging (ambient, for libs):

// file1
interface Window {
    custom: string;
}

// file2 (merges)
interface Window {
    another: number;
}

// Result: Window { ..., custom: string, another: number }

Function и Index Signatures:
Interfaces for callables, dynamic keys.
Пример function signature:

interface SearchFunc {
    (query: string, maxResults?: number): string[];  // Call sig
}

const search: SearchFunc = (q, max = 10) => [q];  // Matches
// Error: search = () => {} — no params

// Multiple overloads
interface MultiFunc {
    (a: number, b: number): number;
    (a: string, b: string): string;
}

Index (dynamic props):

interface StringDict {
    [key: string]: string;  // Any string key → string value
}

const dict: StringDict = { name: 'Alice', role: 'user' };  // OK
dict.age = '30';  // OK, but age: string (loose)

interface NumberDict {
    [key: string]: number | string;  // Union values
    length: number;  // Known prop
}

React Integration (Props/Events):
Interfaces for components, events.
Пример React props:

import React from 'react';

interface ButtonProps {
    label: string;
    onClick: (event: React.MouseEvent<HTMLButtonElement>) => void;  // Typed event
    disabled?: boolean;
    variant?: 'primary' | 'secondary';  // Literal union
}

const Button: React.FC<ButtonProps> = ({ label, onClick, disabled = false, variant = 'primary' }) => (
    <button
        onClick={onClick}
        disabled={disabled}
        className={`btn ${variant}`}  // TS knows variant
    >
        {label}
    </button>
);

// Usage
const handleClick = (e: React.MouseEvent<HTMLButtonElement>) => {
    console.log(e.target);  // Typed target: HTMLButtonElement
};

<Button label="Submit" onClick={handleClick} variant="primary" />;  // OK
// Error: <Button label={123} /> — label: number ≠ string

State/events: interface State { users: User[]; loading: boolean; }.

Go Backend Integration (API Contracts):
Interfaces for JSON shapes.
Пример typed API response:

interface User {
    id: number;
    name: string;
    email: string;
}

interface ApiResponse<T> {  // Generic interface
    data: T;
    success: boolean;
    message?: string;
}

interface CreateUserRequest {
    name: string;
    email: string;
}

interface CreateUserResponse extends ApiResponse<User> {
    id: number;  // Override/add
}

// Fetch
async function createUser(req: CreateUserRequest): Promise<CreateUserResponse> {
    const res = await fetch('/api/users', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(req)
    });
    const data = await res.json() as CreateUserResponse;  // Enforce shape
    // Error if data.data.name missing — compile if mismatched
    return data;
}

// Go match
// struct User { ID int; Name string; Email string; }
// /api/users: json.Decode(req.Body, &user) — matches interface

OpenAPI: Generated interface User from Go docs.

Readonly, Optional и Advanced:

Readonly: Prevent mutation (readonly id: number).

interface Point {
    readonly x: number;
    readonly y: number;
}
const p: Point = { x: 10, y: 20 };
// p.x = 30;  // Error: readonly

Utility: With Partial<T> (all ?), Readonly<T> (all readonly).

type PartialUser = Partial<User>;  // {id?: number; name?: string; ...}

Interfaces vs. Types:

Interfaces: Objects/classes, extendable (extends), mergable.
Types: Primitives/unions (type ID = string | number), intersections (&).
Prefer interfaces for shapes, types for computations (e.g., type Status = 'loading' | 'error').

Best Practices:

Name: PascalCase (User, Props).
Optional for flexibility (?:), readonly for immutability.
Extend sparingly (flat hierarchies).
React: FC<Props> or defineComponent (Vue).
With Go: Generate from protobuf/OpenAPI (no manual sync).
Testing: Mock interfaces (const mockUser: User = { ... }).

Interfaces — TS contracts для robust objects/APIs, enabling safe extension. В Go+React: Interface User = typed Go JSON, no runtime surprises. Prep: Define User interface — use in func, see errors.

Вопрос 32. Что такое Webpack и как вы его используете?

Таймкод: 00:30:28

Ответ собеседника: неполный. Сборщик для сборки, сжатия и минимизации файлов; не настраивал сам, использует конфиг и плагины.

Правильный ответ:
Webpack — это мощный module bundler и build tool для современных JS/TS приложений (React, Vue, Angular), который собирает (bundles) модули (JS, CSS, images, fonts) в оптимизированные статические файлы (chunks/bundles), разрешая зависимости (import/export), tree-shaking (удаление dead code) и code splitting (lazy loading). Он обрабатывает assets через loaders (transformers, e.g., babel-loader для TS/JSX transpilation, css-loader для styles), plugins (extensions, e.g., HtmlWebpackPlugin для index.html injection, TerserPlugin для minification), и modes (development: source maps/hot reload; production: uglification/caching). В отличие от простых bundlers (Parcel zero-config), Webpack highly configurable (webpack.config.js), enabling perf (gzip, cache busting) и extensibility (custom loaders/plugins). Использую Webpack в React+TS проектах: Через CRA (create-react-app) для quick start (eject для custom), или Vite (modern alternative, faster HMR), с manual config для large apps (code splitting routes, SSR). В production: Builds optimized bundles (stats.json для analysis), serves via Go (http.FileServer for /dist). Без Webpack raw JS — no modularity (browser limits), manual concatenation. Senior-практика: Dynamic imports (React.lazy), bundle analyzer (webpack-bundle-analyzer), и integration с Go (webpack serve static API responses). Webpack — backbone front-end builds, от dev speed to prod efficiency.

Webpack processes graph: Entry → modules (resolve/load) → bundle (output). CLI: npx webpack --mode=production.

Core Concepts и Workflow:

Entry/Output: Entry — start points (src/index.ts), output — dist/main.js (path, filename).
Loaders: Pre/post-process files (e.g., ts-loader for .ts → JS). Chain: raw → transformed.
Plugins: Lifecycle hooks (e.g., DefinePlugin for env vars).
Resolvers: Handle imports (aliases: @/components → src/components).
DevServer: Hot Module Replacement (HMR) for live reload.

Пример basic webpack.config.js (React+TS):

const path = require('path');
const HtmlWebpackPlugin = require('html-webpack-plugin');
const { CleanWebpackPlugin } = require('clean-webpack-plugin');

module.exports = (env, argv) => ({
    mode: argv.mode || 'development',  // dev/prod
    entry: './src/index.tsx',  // TSX entry
    output: {
        path: path.resolve(__dirname, 'dist'),
        filename: '[name].[contenthash].js',  // Hash for cache busting
        clean: true,  // Clean dist
    },
    resolve: {
        extensions: ['.tsx', '.ts', '.js'],  // Resolve TS/JS
        alias: {
            '@': path.resolve(__dirname, 'src'),  // @import
        },
    },
    module: {
        rules: [
            {
                test: /\.tsx?$/,  // TS/TSX
                use: 'ts-loader',  // Transpile to JS
                exclude: /node_modules/,
            },
            {
                test: /\.css$/,  // CSS
                use: ['style-loader', 'css-loader'],  // Inject styles
            },
            {
                test: /\.(png|svg|jpg|gif)$/,  // Images
                type: 'asset/resource',  // Emit files, url-loader equiv
            },
        ],
    },
    plugins: [
        new CleanWebpackPlugin(),  // Clean dist
        new HtmlWebpackPlugin({
            template: './public/index.html',  // Inject bundle
            filename: 'index.html',
        }),
        ...(argv.mode === 'production' ? [new TerserPlugin()] : []),  // Minify prod
    ],
    devServer: {
        static: path.join(__dirname, 'dist'),  // Serve dist
        port: 3000,
        hot: true,  // HMR
        open: true,  // Auto-open browser
        historyApiFallback: true,  // SPA routing
    },
    optimization: {
        splitChunks: {  // Code splitting
            chunks: 'all',  // Vendor chunks
        },
        minimize: argv.mode === 'production',  // Uglify
        usedExports: true,  // Tree-shaking
    },
    devtool: argv.mode === 'development' ? 'source-map' : false,  // Maps for debug
});

Run: npx webpack --mode=development (dev) / --mode=production (build).

Usage in Projects:
В React+TS: CRA uses Webpack under (npm start → devServer; npm run build → prod bundle). Custom: Eject CRA или init with webpack (yarn add -D webpack webpack-cli ts-loader html-webpack-plugin). Для large apps: Dynamic imports (const Comp = lazy(() => import('./Comp'))) — splits to chunks (main.js, 0.chunk.js), loaded on demand (perf: initial load <100KB). HMR: Changes → hot update без full reload.

Пример code splitting (React routes):

// App.tsx
import React, { lazy, Suspense } from 'react';

const Users = lazy(() => import('./Users'));  // Split to users.chunk.js
const Profile = lazy(() => import('./Profile'));  // profile.chunk.js

function App() {
    return (
        <Suspense fallback={<div>Loading...</div>}>
            <Routes>
                <Route path="/users" element={<Users />} />
                <Route path="/profile" element={<Profile />} />
            </Routes>
        </Suspense>
    );
}

Webpack: Analyzes imports → creates chunks, loads async (fetch('/users.chunk.js')).

Integration with Go Backend:
Go serves webpack bundles (static files).
Пример Go server (mux + static):

package main

import (
    "net/http"
    "github.com/gorilla/mux"
)

func main() {
    r := mux.NewRouter()
    r.PathPrefix("/api").HandlerFunc(apiHandler)  // API endpoints
    r.PathPrefix("/").Handler(http.FileServer(http.Dir("./dist")))  // Serve webpack dist
    http.ListenAndServe(":8080", r)
}

func apiHandler(w http.ResponseWriter, r *http.Request) {
    // e.g., /api/users → JSON
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode([]User{{ID: 1, Name: "Alice"}})
}

Frontend: fetch('/api/users') — CORS if needed (Go: w.Header().Set("Access-Control-Allow-Origin", "*")). Webpack devServer proxy: devServer.proxy: { '/api': 'http://localhost:8080/' } — dev API to Go. Prod: Build webpack → copy dist to Go static dir.

Optimization и Plugins/Loaders:

Loaders: Babel (ES6+ → ES5), file-loader (assets), postcss (CSS transforms).
Plugins: CopyWebpackPlugin (assets), MiniCssExtractPlugin (separate CSS), webpack.DefinePlugin({ 'process.env.API_URL': JSON.stringify('http://localhost:8080/') }).
Perf: Analyze (webpack-bundle-analyzer plugin: visualize sizes), split (vendor: react → separate), cache (cache: { type: 'filesystem' } — faster rebuilds). Tree-shaking: ES modules only (sideEffects: false in package.json).
Alternatives: Vite (faster, ES native), esbuild (ultra-fast, but less plugins).

Пример advanced config snippet (env + env vars):

const webpack = require('webpack');

plugins: [
    new webpack.DefinePlugin({
        'process.env.NODE_ENV': JSON.stringify(argv.mode),
        'process.env.API_BASE': JSON.stringify('http://localhost:8080/api'),  // Go API
    }),
]

TS: Use ts-loader or babel-loader + @babel/preset-typescript.

Best Practices:

Start simple (CRA/Vite), custom when need (e.g., custom loaders for Go protobuf).
Modes: Separate config (webpack.dev.js/prod.js) или env flags.
Security: No eval in prod (devtool: false).
Testing: Webpack in CI (yarn build → check sizes).
With Go: Embed bundles (go:embed dist/* → http.FS), or separate (Nginx proxy).

Webpack — essential для modular, optimized front-ends, bridging dev (HMR) to prod (minified). В Go+React: Bundles + Go static/API = full-stack deploy. Prep: Init webpack TS app, add loader — build/observe dist.

Вопрос 33. Чем Angular отличается от React для разработчиков?

Таймкод: 00:31:15

Ответ собеседника: неполный. Angular более полный из коробки, React - более кастомизируемый и гибкий, требует дополнительных библиотек.

Правильный ответ:
Angular и React — два популярных инструмента для frontend-разработки, но Angular — это полноценный framework (от Google, 2009, v2+ 2016), ориентированный на enterprise-приложения с встроенной структурой (MVC/MVVM, DI, routing, forms, HTTP client), в то время как React — библиотека (от Facebook, 2013) для declarative UI-компонентов, фокусирующаяся на виртуальном DOM и JSX, с высокой гибкостью, но требующая сборки экосистемы (state management как Redux, routing как React Router). Для разработчиков Angular предлагает opinionated подход (меньше решений, быстрее onboarding в large teams, но steeper curve), React — composability и speed (быстрее прототипы, огромный ecosystem, но boilerplate для scale). Angular mandatory TypeScript (strong typing, decorators), React optional (JS/TS, hooks). В production Angular генерирует AOT-optimized bundles (smaller, faster initial load), React — tree-shakable с Webpack/Vite (dynamic imports). Без Angular/React raw DOM — imperative, slow updates; оба enable SPA. Для Go-backend: Оба fetch API (Angular HttpClient typed, React fetch/axios), но Angular DI упрощает services (inject HttpClient), React — custom hooks. Выбор: Angular для structured enterprise (banks, dashboards), React для dynamic UIs (social, e-commerce). Senior-практика: Angular modules/lazy-loading для perf, React Server Components (Next.js) для SSR. Angular — batteries-included, React — lightweight, extensible.

Angular CLI (ng new) — zero-config scaffold (components, services), React CRA/Vite — similar, но React favors composition (higher-order components/hooks). Learning: React 1-2 weeks (components, state), Angular 1-2 months (zones, RxJS, pipes).

Архитектура и Структура:
Angular: Hierarchical (modules, components, services, directives), two-way binding (ngModel), RxJS observables для async (built-in). Opinionated: One-way data flow with change detection (Zone.js tracks async).
React: Unidirectional (props down, events up), one-way binding, hooks (useState, useEffect) для state/lifecycle. Flexible: No modules — files/folders, composition via children/props.
Пример Angular component (typed service):

// user.service.ts (DI)
import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { Observable } from 'rxjs';

export interface User { id: number; name: string; }

@Injectable({ providedIn: 'root' })
export class UserService {
    constructor(private http: HttpClient) {}  // Injected

    getUsers(): Observable<User[]> {
        return this.http.get<User[]>('/api/users');  // Typed, RxJS
    }
}

// user.component.ts
import { Component, OnInit } from '@angular/core';
import { UserService, User } from './user.service';

@Component({
    selector: 'app-user',
    template: `
        <ul>
            <li *ngFor="let user of users">{{ user.name }}</li>  <!-- Structural dir -->
        </ul>
        <button (click)="loadUsers()">Load</button>  <!-- Event binding -->
    `
})
export class UserComponent implements OnInit {
    users: User[] = [];

    constructor(private userService: UserService) {}  // DI

    ngOnInit() { this.loadUsers(); }

    loadUsers() {
        this.userService.getUsers().subscribe(users => this.users = users);  // RxJS sub
    }
}

Angular: Auto DI, observables chainable (pipe/map), templates declarative ( *ngFor like React map).

Пример React equivalent (custom hook):

// useUsers.ts (custom hook, no DI)
import { useState, useEffect } from 'react';
import { User } from './types';  // TS interface

export function useUsers() {
    const [users, setUsers] = useState<User[]>([]);
    const [loading, setLoading] = useState(true);

    useEffect(() => {
        fetch('/api/users')  // Or axios
            .then(res => res.json())
            .then((data: User[]) => { setUsers(data); setLoading(false); });
    }, []);

    return { users, loading };
}

// UserComponent.tsx
import React from 'react';
import { useUsers } from './useUsers';

export const UserComponent: React.FC = () => {
    const { users, loading } = useUsers();

    if (loading) return <div>Loading...</div>;

    return (
        <ul>
            {users.map(user => <li key={user.id}>{user.name}</li>)}  // JSX map
        </ul>
    );
};

React: Hooks encapsulate logic (reusable), no built-in HTTP (add react-query/SWR for caching), JSX imperative in JS.

Developer Experience (DX) и Экосистема:
Angular: CLI powerful (ng generate component/service, ng serve/build/test), RxJS/Angular Material built-in (UI/forms), but verbose (decorators @Component). Testing: Jasmine/Karma integrated. Learning curve: High (concepts: modules, zones, pipes).
React: Create React App/Vite fast setup, ecosystem vast (Material-UI, AntD for UI; Redux Toolkit, Zustand for state; React Router for routing). Hooks simple (useState like setState), but decisions (which router? state lib?). Testing: Jest + React Testing Library. DX: Faster iteration (HMR in Vite <1s), community larger (npm trends).
Для devs: Angular enforces consistency (good for teams >10), React empowers creativity (but anti-patterns easier).

Performance и Scalability:
Angular: AOT compilation (pre-compile templates, smaller bundles ~30% less), Ivy renderer (tree-shakable). Change detection optimized (OnPush strategy). Scale: Enterprise (Google apps), but heavier initial (~140KB gzipped min).
React: Virtual DOM diffing efficient, concurrent mode (Suspense), code splitting native (React.lazy). Scale: Facebook/Netflix, lighter (~40KB), but manual opt (memo, useMemo). Vite: Faster builds (esbuild).
Пример React perf (memoization):

import React, { memo, useMemo } from 'react';

const ExpensiveList: React.FC<{ users: User[] }> = memo(({ users }) => {
    const sorted = useMemo(() => users.sort((a, b) => a.name.localeCompare(b.name)), [users]);  // Avoid re-sort

    return (
        <ul>
            {sorted.map(user => <li key={user.id}>{user.name}</li>)}
        </ul>
    );
});  // Memo prevents re-render if props same

Angular: Built-in trackBy in *ngFor для list perf.

Интеграция с Backend (Go):
Оба: Fetch/HTTP to Go API (JSON User). Angular: HttpClient interceptor (auth, errors), typed Observables (User[]). React: Axios interceptors, typed fetch (as User[]). Go CORS: Both need headers. Angular services — singleton (DI), React contexts/providers.

Когда Выбрать:

Angular: Structured apps (CRUD dashboards, forms-heavy), teams need conventions, TypeScript-first. Pros: Full-stack feel (no lib hunt), accessibility (built-in). Cons: Verbose, slower updates.
React: Interactive UIs (real-time, animations), prototypes, mobile (React Native). Pros: Flexible, vast libs, faster hiring. Cons: Decision fatigue, more setup for state/routing.
В Go+React/Angular: React lighter for API consumer, Angular if need forms/routing out-of-box. Migration: React → Angular harder (paradigm shift). Prep: Build todo app in both — see DX diffs.

Вопрос 34. Пользовались ли вы Git и какие основные команды знаете?

Таймкод: 00:32:06

Ответ собеседника: неполный. Да, пользовался, но конкретные команды не перечислены в субтитрах.

Правильный ответ:
Git — это распределенная система контроля версий (VCS), разработанная Линусом Торвальдсом в 2005 году, позволяющая отслеживать изменения в коде, сотрудничать в командах и управлять историей проекта через snapshots (commits), branches и merges. Она децентрализована (каждый clone — full repo), с локальной историей (no central server required), и используется в 90%+ проектов (GitHub/GitLab/Bitbucket). В Go-разработке Git essential для versioning (go.mod tracks deps), CI/CD (GitHub Actions), и releases (tags как v1.0.0). Использую Git ежедневно: Init/clone repos, feature branches для tasks, pull requests для reviews, rebase для clean history. Workflows: GitFlow (main/develop, feature/hotfix branches) для structured teams, или trunk-based (short-lived branches) для agile. Без Git — manual backups, conflicts hell; Git enables collaboration (diffs, blame). Senior-практика: Interactive rebase (git rebase -i), hooks (pre-commit lint), submodules (for deps как protobuf), и signed commits (GPG для security). В Go: git tag -a v1.0.0 -m "Release" → go get github.com/user/repo@v1.0.0. Git — foundation team dev, от solo to enterprise.

Git core: Working dir (changes), staging (add), repo (commits). Remote: push/pull to origin.

Basic Setup и Local Operations:
Init/clone: Start or copy repo.
Пример init new Go project:

mkdir my-go-app && cd my-go-app
git init  # Local repo (.git dir)
go mod init github.com/user/my-go-app  # Go module
echo "# My Go App" > README.md
git add README.md  # Stage file
git commit -m "Initial commit: Add README"  # Snapshot
git status  # Check staged/untracked
git log --oneline  # View history (short)

Clone: git clone https://github.com/user/repo.git — full history, branches.

Add/Commit/Status: Track changes.

git add <file> (stage specific), git add . (all), git add -A (all incl delete).
git commit -m "Message" (commit staged), git commit -am "Msg" (add+commit tracked).
git status (dirty files), git diff (changes), git diff --staged (staged vs commit).
Best: Atomic commits (one feature/logical change), messages imperative ("Add user handler", not "Added").

Branching и Merging:
Branches: Parallel development (main/master — stable, feature/ — new).
Пример feature branch:

git branch  # List local
git checkout -b feature/user-api  # Create+switch (or git switch -c)
# Edit go files, add/commit
git add .
git commit -m "Implement user API endpoints"
git checkout main  # Switch back
git merge feature/user-api  # Fast-forward or merge commit
git branch -d feature/user-api  # Delete branch

Merge: git merge <branch> (integrate). Conflicts: Edit files, add/commit resolve.
Rebase: git rebase main (replay on top, linear history) — cleaner than merge, but careful (no force-push shared). Interactive: git rebase -i HEAD~3 (squash/edit commits).

Remote Operations и Collaboration:
Remote: Connect to server (GitHub).
Пример push/pull:

git remote add origin https://github.com/user/my-go-app.git  # Add remote
git push -u origin main  # Push+set upstream
git pull origin main  # Fetch+merge (or rebase: git pull --rebase)
git fetch  # Update remotes without merge

Pull Request: Branch → PR on GitHub (review, CI tests). Fetch/PR: git fetch origin pull/ID/head:pr-branch.
Cherry-pick: git cherry-pick <commit> (apply specific change to branch).

Advanced Commands и Workflows:
Log: git log --graph --oneline --all (visual branches), git blame <file> (who changed line).
Reset/Revert: git reset --hard HEAD~1 (undo commit, dangerous), git revert <commit> (safe undo via new commit).
Stash: git stash (temp save changes), git stash pop (apply).
Tags: git tag v1.0.0 (lightweight), git tag -a v1.0.0 -m "Release" (annotated, signed: -s). Push: git push origin v1.0.0. In Go: Semantic versioning (major.minor.patch).
Submodules: git submodule add https://github.com/vendor/lib (nested repo), git submodule update --init.
Hooks: .git/hooks/pre-commit (run go fmt/lint before commit).

Пример GitFlow workflow (Go project):

git checkout develop
git checkout -b feature/add-db
Implement (e.g., database/sql in Go), commit.
git checkout develop; git merge feature/add-db
git checkout -b release/v1.1
Tests/fixes, git tag -a v1.1.0
git checkout main; git merge release/v1.1; git push origin main --tags
git branch -d feature/release

Integration with Go и Tools:
Go projects: Git tracks .go, go.mod/go.sum (git add go.mod). Ignore: .gitignore (bin/, *.exe, vendor/ if vendored). CI: GitHub Actions (on: push, run go test/build). Releases: Git tags trigger builds (e.g., goreleaser). Remote helpers: Go git for deps (go get uses Git).
Best Practices:

Branch naming: feature/task-id-desc, bugfix/..., (e.g., feature/123-user-auth).
Commit conventions: Conventional Commits (feat:, fix:, chore: — for semantic-release).
Security: git config --global user.signingkey <key> (GPG sign commits/tags).
Large repos: git lfs (large files, e.g., protobuf binaries).
Undo: git reflog (recover lost commits). Avoid force-push (-f) on shared branches.

Git — indispensable для Go dev: Version control ensures reproducible builds (go mod tidy + commit), team sync (PRs for code review). В full-stack: Git monorepo (Go backend + React frontend) with paths (backend/, frontend/). Prep: Clone repo, branch/merge, resolve conflict — see history.

Вопрос 1. Какие методы массива вы знаете и используете?​

Вопрос 2. На какие категории делятся итерационные методы массива, например мутирующие и не мутирующие, и в чём их отличие?​

Вопрос 3. Как изменить массив и удалить элементы по условию, желательно в один проход?​

Вопрос 4. Как создать объект в JavaScript?​

Вопрос 5. Какой тип данных у объекта и чем отличаются простые типы от сложных?​

Вопрос 6. Что такое копии объектов, зачем они нужны, в чём разница между глубоким и неглубоким копированием, и как сделать глубокую копию?​

Вопрос 7. Как из массива строк создать объект, где строки станут ключами?​

Вопрос 8. Какие логические операторы есть в JavaScript и что вернёт выражение вроде пустая строка || 1 || [] и '' && 1 && []?​

Вопрос 9. Для чего нужны функции в JavaScript, какие типы функций бывают, чем отличаются классические от стрелочных и почему в React для колбэков используют стрелочные?​

Вопрос 10. Что вы знаете о промисах и используете ли их?​

Вопрос 11. Какие состояния бывают у промиса, для чего используются then, catch и finally, в каких случаях finally выполняется, и какая альтернатива промисам?​

Вопрос 12. Сталкивались ли вы с библиотекой Axios и для чего она?​

Вопрос 13. Чем отличаются GET и POST запросы с точки зрения фронтенд-разработки?​

Вопрос 14. Чем отличаются protected и public методы в контексте фронтенда?​

Вопрос 15. Зачем нужен React для разработчика и пользователя, в чём его преимущества?​

Вопрос 16. В чём именно ускорение разработки в React?​

Вопрос 17. Как JSX преобразуется в JavaScript и какие инструменты используются?​

Вопрос 18. Как работает Virtual DOM в React?​

Вопрос 19. Как именно происходит сравнение в Virtual DOM, учитывая ссылочные типы объектов?​

Вопрос 20. Что делает React после сравнения Virtual DOM?​

Вопрос 21. Какие триггеры вызывают перерендер компонента в React?​

Вопрос 22. В чём разница при прокидывании обычной функции и мемоизированной с useCallback в обычный компонент без обёрток?​

Вопрос 23. Для чего нужны хуки в React?​

Вопрос 24. Почему в React использовать useState вместо обычной переменной?​

Вопрос 25. Как управлять срабатыванием useEffect через зависимости и когда оно выполняется без них или с пустым массивом?​

Вопрос 26. Как вы использовал Redux и для чего он нужен?​

Вопрос 27. Как в компоненте получить данные из Redux state без передачи через props?​

Вопрос 29. Какую роль играет TypeScript для бизнеса после деплоя проекта?​

Вопрос 30. Какие основные типы данных есть в TypeScript?​

Вопрос 30. Что такое generics в TypeScript?​

Вопрос 31. Что такое интерфейсы в TypeScript?​

Вопрос 32. Что такое Webpack и как вы его используете?​

Вопрос 33. Чем Angular отличается от React для разработчиков?​

Вопрос 34. Пользовались ли вы Git и какие основные команды знаете?​

Вопрос 1. Какие методы массива вы знаете и используете?

Вопрос 2. На какие категории делятся итерационные методы массива, например мутирующие и не мутирующие, и в чём их отличие?

Вопрос 3. Как изменить массив и удалить элементы по условию, желательно в один проход?

Вопрос 4. Как создать объект в JavaScript?

Вопрос 5. Какой тип данных у объекта и чем отличаются простые типы от сложных?

Вопрос 6. Что такое копии объектов, зачем они нужны, в чём разница между глубоким и неглубоким копированием, и как сделать глубокую копию?

Вопрос 7. Как из массива строк создать объект, где строки станут ключами?

Вопрос 8. Какие логические операторы есть в JavaScript и что вернёт выражение вроде пустая строка || 1 || [] и '' && 1 && []?

Вопрос 9. Для чего нужны функции в JavaScript, какие типы функций бывают, чем отличаются классические от стрелочных и почему в React для колбэков используют стрелочные?

Вопрос 10. Что вы знаете о промисах и используете ли их?

Вопрос 11. Какие состояния бывают у промиса, для чего используются then, catch и finally, в каких случаях finally выполняется, и какая альтернатива промисам?

Вопрос 12. Сталкивались ли вы с библиотекой Axios и для чего она?

Вопрос 13. Чем отличаются GET и POST запросы с точки зрения фронтенд-разработки?

Вопрос 14. Чем отличаются protected и public методы в контексте фронтенда?

Вопрос 15. Зачем нужен React для разработчика и пользователя, в чём его преимущества?

Вопрос 16. В чём именно ускорение разработки в React?

Вопрос 17. Как JSX преобразуется в JavaScript и какие инструменты используются?

Вопрос 18. Как работает Virtual DOM в React?

Вопрос 19. Как именно происходит сравнение в Virtual DOM, учитывая ссылочные типы объектов?

Вопрос 20. Что делает React после сравнения Virtual DOM?

Вопрос 21. Какие триггеры вызывают перерендер компонента в React?

Вопрос 22. В чём разница при прокидывании обычной функции и мемоизированной с useCallback в обычный компонент без обёрток?

Вопрос 23. Для чего нужны хуки в React?

Вопрос 24. Почему в React использовать useState вместо обычной переменной?

Вопрос 25. Как управлять срабатыванием useEffect через зависимости и когда оно выполняется без них или с пустым массивом?

Вопрос 26. Как вы использовал Redux и для чего он нужен?

Вопрос 27. Как в компоненте получить данные из Redux state без передачи через props?

Вопрос 29. Какую роль играет TypeScript для бизнеса после деплоя проекта?

Вопрос 30. Какие основные типы данных есть в TypeScript?

Вопрос 30. Что такое generics в TypeScript?

Вопрос 31. Что такое интерфейсы в TypeScript?

Вопрос 32. Что такое Webpack и как вы его используете?

Вопрос 33. Чем Angular отличается от React для разработчиков?

Вопрос 34. Пользовались ли вы Git и какие основные команды знаете?