Подготовка к собеседованию — Full-Stack разработчик

Короткий ответ: SELECT извлекает строки из таблиц. Логический порядок выполнения НЕ совпадает с порядком написания: сначала FROM, затем WHERE, GROUP BY, HAVING, SELECT, DISTINCT, ORDER BY, LIMIT.

Подробно:

Порядок написания (синтаксический):

SELECT   DISTINCT col1, agg(col2)
FROM     t
WHERE    cond
GROUP BY col1
HAVING   agg_cond
ORDER BY col1
LIMIT    10 OFFSET 20;

Логический порядок исполнения:

1. FROM / JOIN      -- какие таблицы, как соединить
2. WHERE            -- фильтр строк ДО группировки
3. GROUP BY         -- группировка
4. HAVING           -- фильтр групп ПОСЛЕ агрегации
5. SELECT           -- выражения, алиасы, оконные функции
6. DISTINCT         -- удаление дублей
7. ORDER BY         -- сортировка
8. LIMIT / OFFSET   -- срез

⚠️ Ловушка: алиас из SELECT нельзя использовать в WHERE (т.к. WHERE выполняется раньше SELECT), но можно в ORDER BY и часто в GROUP BY (зависит от СУБД). Пример ошибки:

SELECT salary * 12 AS annual FROM emp WHERE annual > 100000; -- ОШИБКА
SELECT salary * 12 AS annual FROM emp ORDER BY annual;        -- ОК

Короткий ответ: HTTP (HyperText Transfer Protocol) — текстовый прикладной протокол клиент-сервер поверх TCP (в HTTP/3 — поверх QUIC/UDP). Клиент отправляет запрос, сервер возвращает ответ; соединение без сохранения состояния между запросами (stateless).

Подробно:

Запрос состоит из стартовой строки (метод + путь + версия), заголовков и опционального тела:

POST /api/v1/users HTTP/1.1
Host: api.example.com
Content-Type: application/json
Accept: application/json
Content-Length: 38

{"name": "Анна", "email": "a@ex.com"}

Ответ состоит из строки статуса (версия + код + reason phrase), заголовков и тела:

HTTP/1.1 201 Created
Content-Type: application/json
Location: /api/v1/users/42

{"id": 42, "name": "Анна", "email": "a@ex.com"}

⚠️ Ловушка: «HTTP работает только поверх TCP» — неверно для HTTP/3, который использует QUIC поверх UDP. И reason phrase («OK», «Created») носит чисто информативный характер — клиенты должны опираться на числовой код, а не на текст.

Короткий ответ: В JS 7 примитивных типов (string, number, boolean, null, undefined, symbol, bigint) и один ссылочный тип — объект (включая массивы, функции, даты). Примитивы иммутабельны и копируются по значению, объекты — по ссылке.

Подробно:

// Примитивы — копируются по значению
let a = 10;
let b = a;
b = 20;
console.log(a); // 10 — a не изменилось

// Объекты — копируются по ссылке
let obj1 = { x: 1 };
let obj2 = obj1;
obj2.x = 99;
console.log(obj1.x); // 99 — обе переменные указывают на один объект

// Примитивы иммутабельны: "изменить" строку нельзя, можно только создать новую
let str = "hello";
str[0] = "H";
console.log(str); // "hello" — не изменилось

// bigint — для целых чисел больше 2^53 - 1
const big = 9007199254740993n;
console.log(big + 1n); // 9007199254740994n

// symbol — уникальный идентификатор
const id = Symbol("id");

Примитивы хранят значение напрямую. У них «есть методы» благодаря автоупаковке (autoboxing): "abc".toUpperCase() временно оборачивает строку в объект-обёртку String.

⚠️ Ловушка: typeof function(){} возвращает 'function', хотя функция — это объект. А typeof [] — 'object', поэтому для массивов используйте Array.isArray([]).

Короткий ответ: Same-origin policy разрешает скриптам страницы читать ответы только своего origin (схема + хост + порт). CORS — это согласие сервера: заголовки ответа вроде Access-Control-Allow-Origin сообщают браузеру, каким другим origin можно читать ответ. Проверку выполняет браузер, поэтому чинить нужно на сервере (или через same-origin прокси), а не во фронтенд-коде.

Подробно:

1. Простые запросы — GET, HEAD или POST только с safelisted-заголовками и Content-Type text/plain, multipart/form-data или application/x-www-form-urlencoded. Они уходят сразу, а браузер потом прячет ответ, если Access-Control-Allow-Origin не совпал.
2. Запросы с preflight — всё остальное: PUT/PATCH/DELETE, Content-Type: application/json, заголовок Authorization или кастомный. Браузер сначала шлёт OPTIONS и отправляет настоящий запрос, только если ответ это разрешает. Access-Control-Max-Age кэширует разрешение (Chromium ограничивает его 2 часами).
3. Credentials — при fetch(url, { credentials: "include" }) сервер должен вернуть точный origin (не *) и Access-Control-Allow-Credentials: true, а cross-site cookie нужны SameSite=None; Secure.
4. Чтение заголовков — кроме safelisted-заголовков ответа, JS видит только перечисленные в Access-Control-Expose-Headers.

OPTIONS /orders/42 HTTP/1.1
Origin: https://app.example.com
Access-Control-Request-Method: PUT
Access-Control-Request-Headers: authorization, content-type

HTTP/1.1 204 No Content
Access-Control-Allow-Origin: https://app.example.com
Access-Control-Allow-Methods: GET, PUT
Access-Control-Allow-Headers: authorization, content-type
Access-Control-Allow-Credentials: true
Access-Control-Max-Age: 600
Vary: Origin

⚠️ Частая ошибка: «чинить» CORS на клиенте — добавлять Access-Control-Allow-Origin в запрос или включать mode: "no-cors", который лишь возвращает непрозрачный (opaque) ответ, недоступный для чтения.

Короткий ответ: Big O описывает, как растёт время работы или потребление памяти алгоритма при увеличении размера входных данных n, отбрасывая константы и младшие члены. Это верхняя оценка скорости роста.

Подробно:

Big O отвечает на вопрос «что произойдёт, когда n станет очень большим?». Нас не интересует точное число операций, а только характер роста. Поэтому O(2n + 100) упрощается до O(n), а O(3n² + n) — до O(n²).

Основные классы роста (от лучшего к худшему):

# O(1) — константа: не зависит от n
def first(arr):
    return arr[0] if arr else None

# O(log n) — логарифм: каждый шаг делит задачу пополам (бинарный поиск)
def binary_search(arr, target):
    lo, hi = 0, len(arr) - 1
    while lo <= hi:
        mid = (lo + hi) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            lo = mid + 1
        else:
            hi = mid - 1
    return -1

# O(n) — линейная: один проход
def total(arr):
    s = 0
    for x in arr:        # n итераций
        s += x
    return s

# O(n log n) — эффективные сортировки (merge, quick в среднем, Timsort)
def sort_it(arr):
    return sorted(arr)

# O(n^2) — квадрат: вложенный цикл
def has_dup_naive(arr):
    for i in range(len(arr)):
        for j in range(i + 1, len(arr)):
            if arr[i] == arr[j]:
                return True
    return False

# O(2^n) — экспонента: наивный Фибоначчи, перебор подмножеств
def fib_naive(n):
    if n < 2:
        return n
    return fib_naive(n - 1) + fib_naive(n - 2)

Как оценивать код: последовательные шаги складываются, и остаётся старший член (O(n) + O(n log n) = O(n log n)); вложенные циклы перемножаются (O(n·m), при m = n — O(n²)); отбрасывание половины задачи с постоянной работой на шаге даёт O(log n). Если входов два, сохраняйте обе переменные: O(n + m) нельзя сокращать до O(n), пока не известно, что m ≤ n.

⚠️ Ловушка: Big O — это про асимптотику (поведение при больших n), а не про реальное время. O(n) алгоритм может быть медленнее O(n²) на маленьких данных из-за больших констант. Также путают: Big O (верхняя граница, Ω — нижняя, Θ — точная), в собесах под «O» обычно подразумевают Θ.