Всем привет! Хочу вместе с вами разобрать интересную задачу с собеседований: создание функции sum, которая позволяет выполнять цепочку вызовов вида sum(1)(2, 4)(3) и так далее. Эта задача является отличным тестом на понимание работы замыканий в JavaScript.

Требования к функции:
1. Функция должна корректно обрабатывать несколько последовательных вызовов с любым количеством аргументов.
2. Каждый вызов функции с аргументами должен добавлять эти значения к общей сумме.
3. Если функция вызвана без аргументов, она должна возвращать текущее значение суммы.

Решение:

function sum(...args) {
  let total = args.reduce((acc, cur) => acc + cur, 0);

  function innerSum(...innerArgs) {
    if (!innerArgs.length) return total;
    total += innerArgs.reduce((acc, cur) => acc + cur, 0);
    return innerSum;
  }

  return innerSum;
}

В этом решении ключевым является использование замыкания для накопления суммы чисел между вызовами. Если innerSum вызывается без аргументов, она возвращает накопленный результат.

Пример использования:

console.log(sum(1)(2, 4)(3)()); // Выведет 10

Заключение
Такие задачи позволяют показать глубокое понимание важных концепций JavaScript и умение применять их в практических задачах.

А какие необычные или запоминающиеся задачи вам доводилось решать на собеседованиях?

#interview #javascript

Привет! Наконец-то наступила пятница 🍺 Я, как и многие, всегда жду выходные, потому что можно чуть дольше посидеть за компом и не волноваться о том, что просплю дейли. Сейчас, буквально за пару секунд, я поделился с вами частью своих планов на выходные. Так же быстро и легко можно делиться информацией с помощью Web Share API, о котором пойдет речь сегодня.

Что такое Web Share API?
Web Share API - это интерфейс программирования приложений, который позволяет приложениям использовать нативный механизм обмена данных операционной системы. Проще говоря, это позволяет пользователям делиться контентом, таким как текст, ссылки или файлы, напрямую через встроенные в их устройство функции обмена.

Как это работает?
Вызов navigator.share() открывает нативное диалоговое окно обмена устройства. Этот метод принимает объект, который может содержать 4 свойства:
1. title - заголовок
2. text - текст
3. url - ссылка
4. files - массив файлов

Пример использования:

const shareData = {
  title: '@TrueFrontender',
  text: 'Подпишись!',
  url: 'https://t.me/TrueFrontender'
};

shareButton.addEventListener('click', () => {
  if (!navigator.canShare) {
    console.log('Браузер не поддерживает Web Share API')
  }
  
  if (navigator.canShare && navigator.canShare(shareData)) {
    navigator.share(shareData)
      .then(() => console.log('Поделились!'))
      .catch((error) => console.log('Ошибка:', error));
  } else {
    console.log('Браузер не поддерживает Web Share API для данного типа данных.');
  }
});

canShare - этот метод позволяет проверить, поддерживает ли браузер обмен определенными типами данных, что предотвращает возможные ошибки.

Поддержка
На текущий момент, поддерживается большинством современных мобильных браузеров. Но стоит помнить, что поддержка на десктопных версиях ограничена, поэтому важно предусмотреть альтернативные способы для таких случаев.

Заключение
Web Share API - это мощный и простой инструмент, который может оказать значительное влияние на взаимодействие пользователей с вашим сайтом.

#javascript #webapi

Привет! Сегодня рассмотрим простой алгоритм сортировки. Сортировка вставками (Insertion Sort) — один из базовых, но в то же время эффективных алгоритмов сортировки. Этот метод часто используется из-за его простоты и эффективности на небольших массивах данных.

Что такое сортировка вставками?
Сортировка вставками — это алгоритм сортировки, который строит отсортированный массив элемент за элементом, вставляя каждый следующий элемент в подходящее место. Проще говоря, алгоритм берет элемент и вставляет его в правильное место среди уже отсортированных элементов.

Пример из жизни
Представьте, что у вас есть рука, полная игральных карт. Вы берете карту и, просматривая уже отсортированные в руке карты, вставляете ее в нужное место. Точно так же работает сортировка вставками с массивами данных.

Преимущества:
- Простота реализации.
- Хорошая производительность на небольших массивах.
- Эффективна для массивов, которые уже частично отсортированы.
- Не требует дополнительной памяти.

Пример реализации:

function insertionSort(array) {
  // Проходим по массиву, начиная со второго элемента,
  // так как первый элемент уже считается отсортированным
  for (let currentIndex = 1; currentIndex < array.length; currentIndex++) {
    let currentValue = array[currentIndex]; // Текущий элемент для вставки
    let previousIndex = currentIndex - 1; // Индекс предыдущего элемента

    // Идём назад по массиву и ищем подходящее место для текущего элемента.
    // Элементы, которые больше текущего значения, сдвигаем на один шаг вправо.
    while (previousIndex >= 0 && array[previousIndex] > currentValue) {
      array[previousIndex + 1] = array[previousIndex]; // Сдвигаем элемент вправо
      previousIndex--; // Переходим к следующему элементу для сравнения
    }

    // Вставляем текущий элемент в найденную позицию.
    array[previousIndex + 1] = currentValue;
  }
  return array;
}

// Пример использования
console.log(insertionSort([9, 1, 15, 4, 0]));

Когда использовать?
Сортировка вставками идеально подходит для небольших массивов или для массивов, которые уже частично отсортированы. Она также может быть полезна в ситуациях, где входные данные поступают последовательно и необходимо поддерживать отсортированное состояние данных.

Заключение
Сортировка вставками является хорошим инструментом. Она обеспечивает хорошую производительность на небольших массивах и проста в понимании и реализации.

#interview #javascript #algorithm

Привет 👋! Начнем эту неделю с задачи, которую я встретил на одном из собеседований. Эта задача может и не является популярной, но она достаточно интересна и имеет разные варианты.

Задача
Представьте, что перед вами банкомат, загруженный купюрами различных номиналов, причем каждого номинала в разном количестве. Ваша задача - выдать заданную сумму, используя купюры наибольшего номинала, при этом учитывая их доступное количество.

Пример
В банкомате имеются: 2 купюры по 5000 рублей, 3 купюры по 1000 рублей, 5 купюр по 500 рублей и 10 купюр по 100 рублей. Пользователь хочет снять 8800 рублей. Каков будет ваш подход к выдаче этой суммы, используя купюры наибольшего номинала, которые доступны в банкомате?

Алгоритм решения:
1. Итерируемся по массиву denominations.
2. Для каждого номинала определяем, сколько купюр мы можем использовать, чтобы приблизиться к запрашиваемой сумме, не превышая ее.
3. Вычитаем из запрашиваемой суммы соответствующее количество денег и добавляем данные о выданных купюрах в результат.
4. Продолжаем, пока не выдадим всю запрашиваемую сумму или пока не пройдем все доступные номиналы.

Решение:

const denominations = [
  [5000, 2],
  [1000, 3],
  [500, 5],
  [100, 10]
];

function withdraw(amount) {
  let result = [];

  for (let [denom, count] of denominations) {
    let usableCount = Math.min(count, Math.floor(amount / denom));
    if (usableCount > 0) {
      amount -= usableCount * denom;
      result.push([denom, usableCount]);
    }
    if (amount === 0) break;
  }

  return amount === 0 ? result : null; // Возвращаем null, если не можем выдать всю сумму
}

console.log(withdraw(8800));

А теперь интересно узнать ваше мнение! Как вам эта задача? Какие альтернативные способы решения этой задачи вы можете предложить?

#javascript #interview

Приветствую всех! Сегодня мы обсудим одну из фундаментальных тем в CSS - вес селекторов. Это поможет нам понять, как браузер решает, какие стили применять к элементу, когда имеется несколько конкурирующих правил.

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

Вес селектора определяется на основе трех типов селекторов:
1. ID селекторы (#id) имеют самый высокий вес.
2. Классы, псевдоклассы и атрибуты (.class, :hover, [type="text"]) следуют за ID по весу.
3. Элементы и псевдоэлементы (например, div, ::after) имеют самый низкий вес.

Специфичность селектора можно представить в виде чисел, например: 0,1,0,0 для ID селектора, 0,0,1,0 для класса, и 0,0,0,1 для типа элемента. Но почему используются именно четыре цифры? Это связано с тем, что первая цифра отвечает за инлайновые стили (атрибут style в HTML), которые имеют самый высокий приоритет.

Правила подсчета:
Специфичность считается слева направо: инлайновые стили, затем ID, классы/псевдоклассы/атрибуты, и в конце элементы/псевдоэлементы. Более специфичный селектор переопределяет менее специфичные, даже если они объявлены позже.

Примеры:
- Селектор #header (вес 0,1,0,0) переопределит .main .header (вес 0,0,2,0) из-за наличия ID селектора.
- Селектор .button.active (вес 0,0,2,0) будет иметь больший приоритет, чем .button (вес 0,0,1,0) благодаря дополнительному классу.
- Селектор div span (вес 0,0,0,2) будет менее специфичным, чем .element (вес 0,0,1,0), несмотря на использование двух типов элементов.

Важные моменты:
- Универсальный селектор (*), комбинаторы (например, +, >) и отрицание (:not()) не влияют на вес.
- Стили, объявленные в атрибуте style HTML элемента, всегда имеют наивысший приоритет (за исключением !important).
- Использование !important в CSS объявлении может переопределить другие стили, независимо от их специфичности, но следует избегать его частого использования. В этом посте(тык) я делился своими мыслями на счет !important.

Почему это важно?
Понимание веса селекторов критически важно для эффективной работы с CSS. Это помогает в избежании конфликтов стилей и позволяет писать более предсказуемый и управляемый код.

Заключение
Итак, мы разобрали, как браузер определяет, какие стили нужно применить к элементу, на основе веса селекторов. Это знание помогает создавать стили, которые ведут себя ожидаемо и легче поддаются дебаггингу. Понимание специфичности селекторов позволяет вам избегать излишнего использования !important и обеспечивает более чистый, поддерживаемый код.

#css

Привет! Сегодня я хочу поговорить о принципе DRY (Don't Repeat Yourself) и поделиться своими мыслями о том, как его правильно применять.

Применение DRY не всегда означает стремление к избавлению от любого дублирования кода. На самом деле, ключ к успешному использованию DRY заключается в понимании, когда и как нужно обобщать код.

Вот простой и эффективный подход к применению DRY:
1. Когда вы сталкиваетесь с новой задачей, начните с решения, нацеленного на конкретный случай. Это позволяет быстрее разработать работающий код и лучше понять задачу.
2. Если похожая задача возникает во второй раз, используйте уже написанный код, адаптируя его под новые условия. Важно здесь отметить в коде, что произошло повторение, чтобы быть осведомленным о потенциальной необходимости в дальнейшем обобщении.
3. Когда вы сталкиваетесь с проблемой в третий раз, это является сигналом к обобщению. Теперь у вас есть достаточно контекста и понимания для создания универсального решения.

Этот подход помогает избежать преждевременной абстракции и усложнения кода. Он также позволяет более глубоко понять проблему, прежде чем переходить к обобщенному решению.

DRY — это не просто правило избегать дублирования кода, а скорее стремление к упрощению и улучшению архитектуры вашего проекта. Помните, что ключевым фактором здесь является баланс: найти золотую середину между частными решениями и обобщенными подходами.

А что вы думаете на счет DRY?

Всех с пятницей! Сегодня хочу рассмотреть не очень известный, но очень полезный метод navigator.sendBeacon(). Этот метод позволяет отправлять асинхронные запросы на сервер перед закрытием страницы, и это открывает нам несколько интересных возможностей. Давайте разберемся, в чем его особенность и как его можно использовать.

Что такое sendBeacon?
Метод sendBeacon был введен для решения проблемы отправки данных на сервер при закрытии страницы или при уходе пользователя с сайта по ссылке.

Как работает sendBeacon?
navigator.sendBeacon(url, data) принимает два аргумента: url сервера, куда вы хотите отправить данные, и data – сами данные. Самое интересное, что отправка данных происходит асинхронно и браузер не ожидает ее завершения перед закрытием страницы.

Примеры использования:
- Отправка аналитики на сервер.
- Отслеживание ухода пользователя с сайта. Можно отправлять информацию о времени, проведенном на странице.
- Сохранение состояния приложения перед выходом пользователя, чтобы в следующий раз он мог продолжить с того же места.

Пример

window.addEventListener('unload', function() {
  navigator.sendBeacon('/log', JSON.stringify({userAction: 'pageClose'}));
});

Заключение
Этот метод позволяет нам улучшить пользовательский опыт, собирая ценные данные без заметных задержек для пользователя. Он решает конкретную проблему без лишних сложностей для разработчиков и пользователей.

#javascript

Привет всем! Новая неделя - новые возможности для обучения. Надеюсь, вы успели отдохнуть) Сегодня мы разберем классическую задачу с собеседования - реализацию дебаунсинга (debouncing). Хотя на практике мы часто используем готовые библиотеки для таких целей, на собеседованиях любят проверять понимание основных концепций.

Что такое debouncing?
Дебаунсинг - это техника уменьшения количества вызовов функции, которая может быть запущена повторно в короткий промежуток времени. Это особенно полезно для функций, вызываемых в ответ на события ввода или прокрутки, чтобы избежать чрезмерных вычислений или запросов к серверу.

Алгоритм решения:
1. Создайте функцию debounce, которая принимает функцию func и время ожидания wait в миллисекундах.
2. Объявите переменную timeout внутри debounce, которая будет служить для хранения идентификатора таймера от setTimeout.
3. Функция debounce возвращает новую функцию, создающую замыкание с доступом к переменной timeout и параметрам func и wait.
4. В начале каждого вызова возвращаемой функции отменяйте предыдущий таймер с помощью clearTimeout.
5. Настройте новый таймер с помощью setTimeout, который вызывает func с текущими аргументами после задержки wait.
6. Возвращаемая функция собирает все переданные ей аргументы с помощью оператора расширения ...args и передает их в func при вызове.

Реализация:

const debounce = (func, wait) => {
    let timeout;

    return (...args) => {
        clearTimeout(timeout);
        timeout = setTimeout(() => func(...args), wait);
    };
};

// Пример использования
const debouncedInputHandler = debounce(event => {
    console.log(event.target.value);
}, 500);

В этом примере функция debounce действует как декоратор, создавая обертку вокруг вашей функции и гарантируя, что она не будет вызываться чаще, чем раз в указанное время (в примере 500 мс), независимо от того, насколько часто происходит событие.

Такой подход не только оптимизирует производительность, но и помогает сохранять ресурсы, делая приложение более отзывчивым и дружелюбным к пользователю.

А какие интересные задачи встречались вам на собеседованиях и как вам эта задача? Поделитесь своим опытом в комментариях!

#interview #javascript #patterns

Привет! Сегодня наша тема – хук useReducer в React. Все знакомы с useState, но useReducer зачастую уходит в тень, хотя предлагает великолепные возможности для управления состоянием.

Что такое useReducer и когда его использовать?
useReducer - это хук, который позволяет управлять состоянием компонента более контролируемым и предсказуемым способом, особенно когда у вас сложная логика состояний или большое количество изменяемых данных.

Как работает useReducer?
useReducer принимает три аргумента:
1. Функция, которая определяет, как состояние должно изменяться в ответ на определённые действия. Эта функция принимает текущее состояние и действие в качестве аргументов и возвращает новое состояние.

function reducer(state, action) {
  switch (action.type) {
    // логика обработки действий
  }
}

2. Начальное состояние, которое будет использоваться в первый момент, когда компонент рендерится.

const initialState = { count: 0 };

3. Необязательная функция для расчета начального состояния. Она принимает начальное состояние в качестве аргумента и возвращает фактическое начальное состояние.

function init(initialState) {
  // Сложная логика для определения начального состояния
  return initialState;
}

После инициализации useReducer, вы получите доступ к двум элементам: текущему состоянию и функции dispatch. Функция dispatch используется для отправки действий в ваш reducer.

Пример использования
Давайте рассмотрим классический пример - счётчик. С useState вы бы сделали это так:

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

const increment = () => setCount(prevCount => prevCount + 1);
const decrement = () => setCount(prevCount => prevCount - 1);

Теперь давайте реализуем тот же счётчик, но уже с useReducer:

const initialState = { count: 0 };

function reducer(state, action) {
  switch (action.type) {
    case 'increment':
      return { ...state, count: state.count + 1 };
    case 'decrement':
      return { ...state, count: state.count - 1 };
    default:
      return state
  }
}

const [state, dispatch] = useReducer(reducer, initialState);

// Использование:
dispatch({ type: 'increment' });
dispatch({ type: 'decrement' });

Видите разницу? Вместо прямой модификации состояния, мы отправляем "действие" (action), которое описывает, что именно нужно сделать. Это упрощает отслеживание изменений состояния и делает код более предсказуемым.

Заключение
useReducer - позволяет сделать код более структурированным и упрощает управление сложными состояниями. Использование useReducer не всегда необходимо, но в сложных сценариях он становится настоящим спасением.

#react

Привет фронтендеры! Сегодня мы узнаем о полезном свойстве CSS - counter-reset. Это свойство позволяет нам управлять нумерацией элементов прямо в стилях, что может значительно сократить количество JavaScript кода.

Что такое counter-reset?
counter-reset - это CSS-свойство для создания или сброса CSS-счетчиков. Оно идеально подходит для нумерации списков, автоматической генерации заголовков разделов или подсчета элементов.

Как это работает?
Допустим, у вас есть статья с разделами и подразделами, и вы хотите автоматически пронумеровать их. Вот как может помочь counter-reset:
1. Используйте counter-reset, чтобы создать счетчик. Например, counter-reset: section инициализирует счетчик с именем section.
2. Примените counter-increment для увеличения значения счетчика и content с функцией counter() для отображения. Например, content: counter(section) "." добавит к элементу текст вида "1.", "2." и так далее.
3. Чтобы начать нумерацию заново, просто используйте counter-reset снова.

Пример реализации можно посмотреть здесь - JSFiddle(тык)

Возможности и преимущества:
- counter-reset позволяет управлять нумерацией на уровне CSS, уменьшая зависимость от HTML и JavaScript.
- Счетчики автоматически обновляются при добавлении или удалении элементов.

Заключение
counter-reset - это отличный инструмент, который может значительно упростить вашу работу при структурировании контента. Это свойство позволяет реализовывать различные интересные решения без лишнего кода.

#css

Привет! На очереди у нас декораторы. Может показаться, что это сложно, но на самом деле все не так страшно. Мы вместе разберемся, что это такое, как декораторы работают и почему они могут быть полезны в вашем коде.

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

Как работают декораторы?
Декораторы оборачивают исходную функцию, создавая вокруг неё дополнительный слой логики. Это может быть, например, логирование, измерение времени выполнения, контроль доступа, кэширование и многое другое. Главное преимущество такого подхода в его гибкости: можно легко добавлять или убирать функциональность, не затрагивая основную логику.

Пример из жизни
Представьте, что вы заказываете кофе. Вы можете добавить в него сироп, молоко, сливки - каждая добавка улучшает ваш заказ, не меняя основного продукта.

Пример реализации:

class Coffee {
  cost() {
    return 10;
  }
}

class MilkCoffee {
  constructor(coffee) {
    this.coffee = coffee;
  }

  cost() {
    return this.coffee.cost() + 2;
  }
}

// Использование
const myCoffee = new MilkCoffee(new Coffee());
console.log(myCoffee.cost()); // 12

Кстати, недавно мы разбирали реализацию debounce. Функция debounce тоже является декоратором, так как добавляет новое поведение к функции, не изменяя ее первоначальную структуру. Почитать можно в этом посте(тык).

Плюсы использования декоратора:
- Легко добавлять новые функции без изменения существующих.
- Соблюдение принципа открытости/закрытости. Система остается открытой для расширения, но закрытой для изменения.

Минусы:
- Может усложнить архитектуру, особенно если есть много слоев декораторов.
- Дополнительные слои могут влиять на производительность.

Заключение
Декораторы - помогают нам делать код более модульным, гибким и легко расширяемым. Однако как и любой инструмент, их следует использовать с умом, учитывая потенциальные сложности и влияние на производительность.

#patterns

Привет, фронтендеры! Сегодня мы обсудим один из самых популярных алгоритмов - бинарный поиск. Этот алгоритм часто встречается на собеседованиях, и не зря - владение бинарным поиском показывает вашу способность к алгоритмическому мышлению и умение работать с данными

Что такое бинарный поиск?
Бинарный поиск - это метод поиска элемента в отсортированном массиве. Вместо перебора каждого элемента, алгоритм делит массив на две части и сравнивает искомый элемент с элементом в середине. Если совпадения нет, он исключает половину элементов из дальнейшего поиска, сокращая область поиска вдвое. Этот процесс повторяется до тех пор, пока не будет найден искомый элемент или массив не окажется пустым.

Преимущества:
- В отличие от линейного поиска, бинарный поиск существенно сокращает время поиска, особенно в больших массивах.
- Алгоритм легко реализуется как в итеративной, так и в рекурсивной форме.

Алгоритм решения:
1. Инициализируем два указателя - start и end, которые указывают на начало и конец массива соответственно.
2. Пока start не превышает end, продолжаем поиск. Это гарантирует, что есть элементы для проверки.
3. Вычисляем индекс mid как среднюю точку между start и end. Используем формулу mid = Math.floor(start + (end - start) / 2) для предотвращения переполнения.
4. Если элемент в позиции mid равен искомому x, возвращаем mid, так как элемент найден. Если элемент в mid меньше x, сужаем область поиска, устанавливая start на mid + 1. Если элемент в mid больше x, сужаем область поиска, устанавливая end на mid - 1.
5. Если start превысит end, элемент отсутствует в массиве и мы возвращаем -1.

Пример реализации:

function binarySearch(arr, x) {
    if (arr.length === 0) return -1; // Проверяем, не пустой ли массив

    let start = 0;
    let end = arr.length - 1;

    while (start <= end) {
        let mid = Math.floor(start + (end - start) / 2); // Вычисление середины

        // Сравниваем элемент в середине с искомым значением
        if (arr[mid] === x) {
            return mid; // Элемент найден
        } else if (arr[mid] < x) {
            start = mid + 1; // Искомый элемент больше, продолжаем поиск в правой половине
        } else {
            end = mid - 1; // Искомый элемент меньше, продолжаем поиск в левой половине
        }
    }

    return -1; // Элемент не найден
}

// Пример использования
const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; // Отсортированный массив
const target = 5; // Искомое значение
const position = binarySearch(numbers, target); // Поиск позиции элемента

if (position !== -1) {
    console.log(`Число ${target} найдено на позиции: ${position}`);
} else {
    console.log(`Число ${target} в массиве не найдено.`);
}

Частые ошибки:
- Не правильно выбирать середину массива.
- Не обрабатывать корректно краевые случаи, например, когда массив пуст или содержит только один элемент.

Где используется?
Бинарный поиск применяется во многих областях, от баз данных до поиска в текстах и оптимизации алгоритмов.

Заключение
Освоение бинарного поиска не только улучшит ваше понимание алгоритмов, но и откроет путь к более сложным и интересным задачам поиска и сортировки.

#interview #javascript #algorithm

Привет! Сегодня мы разберем классическую джуновскую задачу с собеседований. Мы узнаем, как определить количество повторений каждого элемента в массиве.

Задача
У нас есть массив, который может содержать как уникальные, так и повторяющиеся элементы. Наша цель - выяснить, сколько раз каждый элемент встречается в этом массиве.

Пример
Возьмем массив хештегов: ["#javascript", "#react", "#patterns", "#css", "#interview", "#javascript", "#css"]. Нам нужно определить, сколько постов приходится на каждый хештег.

Алгоритм решения:
1. Начинаем с пустого объекта, который будет хранить элементы массива как ключи и их количество как значение.
2. Используем метод reduce для перебора каждого элемента в массиве.
3. Проверяем, существует ли уже такой ключ в аккумуляторе. Если да, увеличиваем его значение на 1. Если нет - создаем ключ с начальным значением 1.
4. После обработки всех элементов возвращаем аккумулятор как результат функции.

Решение

function countElements(arr) {
  return arr.reduce((acc, element) => {
    acc[element] = (acc[element] || 0) + 1;
    return acc;
  }, {});
}

// Пример использования
const tags = ["#javascript", "#react", "#patterns", "#css", "#interview", "#javascript", "#css"]
console.log(countElements(tags));

А вы встречали подобные задачи? Делитесь своими мыслями о других способах решения этой задачи или предлагайте свои задачи на будущие разборы.

#interview #javascript