Frontend | Вопросы собесов
Сайт easyoffer.ru Реклама @easyoffer_adv ВП @easyoffer_vp Тесты t.me/+T0COHtFzCJkwMDUy Задачи t.me/+_tcX2w2EmvdmMTgy Вакансии t.me/+CgCAzIyGHHg0Nzky
Show more📈 Analytical overview of Telegram channel Frontend | Вопросы собесов
Channel Frontend | Вопросы собесов (@easy_javascript_ru) in the Russian language segment is an active participant. Currently, the community unites 18 275 subscribers, ranking 7 354 in the Technologies & Applications category and 36 941 in the Russia region.
📊 Audience metrics and dynamics
Since its creation on невідомо, the project has demonstrated rapid growth, gathering an audience of 18 275 subscribers.
According to the latest data from 14 June, 2026, the channel demonstrates stable activity. Although there has been a change in the number of participants by -124 over the last 30 days and by -6 over the last 24 hours, overall reach remains high.
- Verification status: Not verified
- Engagement rate (ER): The average audience engagement rate is 9.62%. Within the first 24 hours after publication, content typically collects 5.70% reactions from the total number of subscribers.
- Post reach: On average, each post receives 1 759 views. Within the first day, a publication typically gains 1 042 views.
- Reactions and interaction: The audience actively supports content: the average number of reactions per post is 8.
- Thematic interests: Content is focused on key topics such as ставь, браузер, html, border, flex.
📝 Description and content policy
The author describes the resource as a platform for expressing subjective opinions:
“Сайт easyoffer.ru
Реклама @easyoffer_adv
ВП @easyoffer_vp
Тесты t.me/+T0COHtFzCJkwMDUy
Задачи t.me/+_tcX2w2EmvdmMTgy
Вакансии t.me/+CgCAzIyGHHg0Nzky”
Thanks to the high frequency of updates (latest data received on 15 June, 2026), the channel maintains relevance and a high level of publication reach. Analytics show that the audience actively interacts with content, making it an important point of influence in the Technologies & Applications category.
observable(). Она превращает объект в реактивный Proxy, который отслеживает чтение (get) и изменение (set) свойств.
import { observable } from "mobx";
const store = observable({
count: 0,
increment() {
this.count++;
},
});
console.log(store.count); // MobX "запоминает", что это свойство использовалось
store.increment(); // MobX "замечает", что свойство изменилось
🚩Как MobX понимает, что нужно обновить компонент Vue?
Vue-компоненты подписываются на реактивные свойства, когда они рендерятся внутри observer().
import { defineComponent } from "vue";
import { observer } from "mobx-vue-lite";
export default observer(defineComponent({
setup() {
return {
store,
};
},
template: `<div>{{ store.count }}</div>`,
}));
🚩Как MobX понимает зависимости? (Track & Re-run)
MobX автоматически отслеживает зависимости во время рендера.
Когда компонент использует store.count, MobX **"запоминает", что он зависит от count.
Когда count изменяется, MobX перерисовывает только этот компонент.
import { computed } from "mobx";
const store = observable({
count: 1,
get doubleCount() {
return this.count * 2;
},
});
console.log(store.doubleCount); // 2
store.count = 2;
console.log(store.doubleCount); // 4 (MobX понимает, что зависимость изменилась)
🚩Как MobX оптимизирует обновления? (Reactions)
MobX не просто перерисовывает всё — он оптимизирует рендеринг.
🟠autorun
запускается сразу и при изменении любого используемого свойства.
🟠reaction
запускается только когда меняется конкретное наблюдаемое свойство.
🟠when
выполняется один раз, когда условие становится true.
import { autorun } from "mobx";
const store = observable({ count: 0 });
autorun(() => {
console.log("Count изменился:", store.count);
});
store.count = 1; // "Count изменился: 1"
store.count = 2; // "Count изменился: 2"
Ставь 👍 и забирай 📚 Базу знанийconsole.log("1: Перед запросом");
setTimeout(() => {
console.log("2: Данные загружены");
}, 2000);
console.log("3: После запроса");
Вывод в консоль
1: Перед запросом 3: После запроса 2: Данные загружены (спустя 2 секунды)🚩Обработка пользовательских событий без зависаний Если бы JavaScript не мог обрабатывать события асинхронно, то нажатия кнопок, прокрутка страницы и другие действия зависали бы, пока выполняется тяжёлая операция. Event Loop ставит события (например,
click, keydown) в очередь и обрабатывает их только когда основной поток свободен.
document.querySelector("button").addEventListener("click", () => {
console.log("Кнопка нажата!");
});
🚩Загрузка данных без блокировки страницы
Когда мы загружаем данные с сервера (fetch, setTimeout, setInterval), они не приходят мгновенно. Без Event Loop браузер бы зависал в ожидании ответа.
Асинхронные запросы (fetch, XMLHttpRequest) выполняются в фоновом режиме. Когда ответ готов, он помещается в очередь задач и обрабатывается, когда основной поток освободится.
console.log("Запрос данных...");
fetch("https://jsonplaceholder.typicode.com/posts/1")
.then(response => response.json())
.then(data => console.log("Данные получены:", data));
console.log("Код выполняется дальше!");
Вывод
Запрос данных...
Код выполняется дальше!
(Спустя время) Данные получены: {id: 1, title: "..."}
🚩Обход блокировки в тяжёлых вычислениях
Если в коде идёт сложная операция (например, сложные вычисления или рендеринг огромного списка), интерфейс зависнет.
Можно разбить задачу на части и выполнять её постепенно с помощью setTimeout или requestAnimationFrame.
let count = 0;
function heavyTask() {
for (let i = 0; i < 1e6; i++) {
count++;
}
console.log("Часть работы выполнена!");
if (count < 5e6) {
setTimeout(heavyTask, 0); // Даем Event Loop обработать другие задачи
}
}
heavyTask();
Ставь 👍 и забирай 📚 Базу знаний.toString() используется для преобразования значения в строку. Он есть у всех объектов в JavaScript, потому что наследуется от Object.prototype. Однако, его поведение зависит от типа данных.
🟠toString() у примитивов
Числа, строки, булевы значения, null, undefined
Для примитивных типов toString() работает просто — возвращает строковое представление значения:
console.log((123).toString()); // "123"
console.log(true.toString()); // "true"
console.log(false.toString()); // "false"
console.log((3.14).toString()); // "3.14"
Но null и undefined не имеют метода toString() и вызов приведёт к ошибке
console.log(null.toString()); // ❌ Ошибка: Cannot read properties of null
console.log(undefined.toString()); // ❌ Ошибка
Поэтому для них лучше использовать String()
console.log(String(null)); // "null"
console.log(String(undefined)); // "undefined"
🟠toString() у массивов
Для массивов toString() преобразует их в строку, разделяя элементы запятой
console.log([1, 2, 3].toString()); // "1,2,3"
console.log(["яблоко", "банан"].toString()); // "яблоко,банан"
console.log([].toString()); // "" (пустая строка)
🟠`toString()` у объектов
По умолчанию метод toString() у объекта возвращает строку вида [object Object]
const obj = { a: 1, b: 2 };
console.log(obj.toString()); // "[object Object]"
Если нужно другое поведение, можно переопределить toString() в объекте
const user = {
name: "Иван",
age: 30,
toString() {
return `Имя: ${this.name}, Возраст: ${this.age}`;
}
};
console.log(user.toString()); // "Имя: Иван, Возраст: 30"
🟠`toString()` у классов
Можно переопределять метод toString() в классах
class Person {
constructor(name, age) {
this.name = name;
this.age = age;
}
toString() {
return `${this.name} (${this.age} лет)`;
}
}
const person = new Person("Анна", 25);
console.log(person.toString()); // "Анна (25 лет)"
🟠`toString()` у функций
Функции тоже имеют метод toString(), но он возвращает их исходный код
function hello() {
return "Привет!";
}
console.log(hello.toString());
// "function hello() { return 'Привет!'; }"
Для стрелочных функций
const sum = (a, b) => a + b;
console.log(sum.toString());
// "(a, b) => a + b"
🟠Использование `String()` вместо `.toString()`
Лучше использовать String(значение), потому что toString() не работает на null и undefined
console.log(String(null)); // "null"
console.log(String(undefined)); // "undefined"
console.log(String(42)); // "42"
console.log(String({ a: 1 })); // "[object Object]"
Ставь 👍 и забирай 📚 Базу знанийuseEffect позволяет выполнять побочные эффекты, такие как запросы к серверу, в функциональных компонентах.
import React, { useState, useEffect } from 'react';
function DataFetchingComponent() {
const [data, setData] = useState(null);
useEffect(() => {
const fetchData = async () => {
try {
const response = await fetch('https://api.example.com/data');
const result = await response.json();
setData(result);
} catch (error) {
console.error('Error fetching data:', error);
}
};
fetchData();
}, []); // Пустой массив означает, что эффект выполнится только при монтировании компонента
return (
<div>
{data ? (
<pre>{JSON.stringify(data, null, 2)}</pre>
) : (
<p>Loading data...</p>
)}
</div>
);
}
export default DataFetchingComponent;
🚩Методы жизненного цикла в классовых компонентах
Метод componentDidMount используется для выполнения запросов к серверу в классовых компонентах после монтирования компонента.
import React, { Component } from 'react';
class DataFetchingComponent extends Component {
constructor(props) {
super(props);
this.state = {
data: null,
};
}
componentDidMount() {
fetch('https://api.example.com/data')
.then(response => response.json())
.then(data => {
this.setState({ data });
})
.catch(error => {
console.error('Error fetching data:', error);
});
}
render() {
const { data } = this.state;
return (
<div>
{data ? (
<pre>{JSON.stringify(data, null, 2)}</pre>
) : (
<p>Loading data...</p>
)}
</div>
);
}
}
export default DataFetchingComponent;
🟠Сервисы или утилиты
Запросы к серверу можно изолировать в отдельные файлы сервисов или утилит, что помогает сделать код более модульным и переиспользуемым.
service.js
export async function fetchData() {
const response = await fetch('https://api.example.com/data');
if (!response.ok) {
throw new Error('Network response was not ok');
}
return response.json();
}
DataFetchingComponent.js
import React, { useState, useEffect } from 'react';
import { fetchData } from './service';
function DataFetchingComponent() {
const [data, setData] = useState(null);
useEffect(() => {
fetchData()
.then(data => setData(data))
.catch(error => console.error('Error fetching data:', error));
}, []);
return (
<div>
{data ? (
<pre>{JSON.stringify(data, null, 2)}</pre>
) : (
<p>Loading data...</p>
)}
</div>
);
}
export default DataFetchingComponent;
🟠Управление состоянием
Для крупных приложений, где важно централизованное управление состоянием, запросы к серверу можно выполнять в рамках таких библиотек, как Redux или MobX.
Ставь 👍 и забирай 📚 Базу знанийReact.memo — это функция в React, которая используется для оптимизации производительности функциональных компонентов. Она предотвращает ненужные повторные рендеры, если пропсы компонента не изменились.
🚩Зачем нужен `React.memo`?
В React каждый раз, когда родительский компонент обновляется, все его дочерние компоненты тоже ререндерятся, даже если их пропсы остались неизменными. Это может негативно сказаться на производительности, особенно если дочерний компонент выполняет сложные вычисления или рендерит большое количество данных.
React.memo решает эту проблему, запоминая (мемоизируя) предыдущий результат рендера и сравнивая его с новыми пропсами. Если пропсы не изменились, компонент просто использует закэшированное представление, а не ререндерится.
🚩Как использовать `React.memo`?
React.memo — это функция высшего порядка (HOC), которая оборачивает функциональный компонент
import React from "react";
const MyComponent = ({ value }) => {
console.log("Рендер компонента!");
return <div>Значение: {value}</div>;
};
// Оборачиваем компонент в React.memo
const MemoizedComponent = React.memo(MyComponent);
export default MemoizedComponent;
🚩Пример без React.memo vs. с React.memo
Допустим, у нас есть родительский компонент, который изменяет состояние при каждом клике
import React, { useState } from "react";
import MemoizedComponent from "./MyComponent";
const Parent = () => {
const [count, setCount] = useState(0);
return (
<div>
<button onClick={() => setCount(count + 1)}>Увеличить</button>
<MemoizedComponent value="Привет, мир!" />
</div>
);
};
export default Parent;
🚩Когда НЕ стоит использовать `React.memo`?
Если компонент всегда ререндерится из-за изменения пропсов – смысла в memo нет.
Если компонент рендерится быстро – оптимизация может быть ненужной, а проверка пропсов даже замедлит работу.
Если пропсы часто изменяются – кэширование теряет смысл, так как все равно ререндерится.
Ставь 👍 и забирай 📚 Базу знанийglobal в Node.js, что делает её доступной для использования в любом окружении.
let timeoutID = setTimeout(function[, delay, arg1, arg2, ...]);
let timeoutID = setTimeout(functionCode[, delay]);
function: Будет вызвана после задержки.
functionCode: Строка кода для выполнения (использование этой формы не рекомендуется по соображениям безопасности).
delay: Задержка в миллисекундах, после которой будет выполнена функция. Если не указать, по умолчанию будет использовано значение 0.
arg1, arg2, ...: Аргументы, которые будут переданы в функцию при её вызове.
function sayHello() {
console.log('Привет!');
}
// Вызывает функцию sayHello после задержки в 2000 миллисекунд (2 секунды)
setTimeout(sayHello, 2000);
🚩Отмена выполнения setTimeout
Вызов ее возвращает идентификатор таймера, который можно использовать для отмены выполнения с помощью функции clearTimeout.
let timerId = setTimeout(sayHello, 2000);
// Отменяет выполнение
clearTimeout(timerId);
🚩Особенности поведения
🟠Минимальная задержка
В HTML5 спецификация предусматривает минимальную задержку в 4ms для вложенных таймеров и в некоторых других случаях, что может повлиять на ожидаемое время выполнения.
🟠Задержка в неактивных вкладках
Браузеры могут изменять поведение таймеров для неактивных вкладок для оптимизации производительности и энергопотребления. Это может привести к значительно большей задержке, чем указано.
🟠Асинхронность
setTimeout не блокирует выполнение кода, который следует за ним. Он лишь запланирует выполнение функции на будущее, позволяя остальному коду продолжать выполняться без ожидания.
Ставь 👍 и забирай 📚 Базу знаний
Available now! Telegram Research 2025 — the year's key insights 
