Frontend | Вопросы собесов
17.7K subscribers
40 photos
3 videos
1.62K links
Сайт: https://easyoffer.ru/
Все каналы: t.me/+xGeAw6ckJ4liYzQy

Контакт для рекламы: @easyoffer_adv
Download Telegram
🤔 Где писать запросы к серверу?

Запросы к серверу в React можно выполнять в нескольких местах в зависимости от архитектуры вашего приложения и используемого подхода.

🚩Использование хуков

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.

Ставь 👍 и забирай 📚 Базу знаний
👍5💊3
🤔 Как происходит tostring?

Метод .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]"


Ставь 👍 и забирай 📚 Базу знаний
👍5🤔1💊1
🤔 В чём разница между макро- и микро-задачами?

Макро-задачи (например, setTimeout, setInterval) выполняются в основном цикле событий после выполнения текущего стека. Микро-задачи (например, Promise, queueMicrotask) имеют более высокий приоритет и выполняются сразу после текущего выполнения кода, до обработки макро-задач. Микро-задачи используются для обработки данных в реальном времени, а макро-задачи — для отложенных действий.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний
👍7🔥3
🤔 Зачем нужен eslint?

ESLint – это инструмент для автоматического анализа и исправления кода в JavaScript и TypeScript. Он помогает разработчикам следовать единым стилям кодирования, находить ошибки и предотвращать баги ещё до запуска кода.

🚩Почему ESLint полезен?
Без линтера код может быть неаккуратным и содержать ошибки, которые сложно отловить.

🚩Проблемы без ESLint

Разные стили написания кода
Пропущенные точки с запятой или лишние пробелы
Неиспользуемые переменные
Ошибки, которые не выявляются во время компиляции (например, undefined переменные)

🚩Решение с ESLint:

Автоматически находит ошибки и предупреждения
Подсказывает лучшие практики
Поддерживает кастомные правила
Работает в IDE и CI/CD (автоматическая проверка)

🟠Как ESLint работает?
ESLint использует набор правил, которые проверяют код. Если код нарушает эти правила – линтер выдаёт предупреждение или ошибку.
function sayHello(name) {
console.log("Hello, " + name)
}

sayHello("John")



Пример исправленного кода (ESLint fix)
function sayHello(name) {
console.log(`Hello, ${name}`);
}

sayHello("John");


🟠Как установить и настроить ESLint?
Установка
npm install eslint --save-dev


Создание конфига
npx eslint --init


Пример .eslintrc.js (настройки ESLint)
module.exports = {
env: {
browser: true,
es6: true,
},
extends: [
"eslint:recommended", // Базовые рекомендации
"plugin:vue/vue3-recommended" // Рекомендации для Vue
],
rules: {
"no-unused-vars": "warn", // Предупреждать о неиспользуемых переменных
"semi": ["error", "always"], // Обязательные точки с запятой
"quotes": ["error", "double"], // Только двойные кавычки
},
};


Запуск проверки кода
npx eslint myfile.js


Автоматическое исправление ошибок
npx eslint myfile.js --fix


🟠ESLint в IDE (VS Code, WebStorm)
Чтобы ESLint работал в VS Code, установите расширение ESLint и включите "editor.codeActionsOnSave"
"editor.codeActionsOnSave": {
"source.fixAll.eslint": true
}


🟠ESLint в CI/CD (автоматическая проверка на сервере)
В проектах ESLint можно запускать в GitHub Actions, Jenkins, GitLab CI и других CI/CD системах, чтобы не допускать ошибок в main ветку.
"scripts": {
"lint": "eslint src --fix"
}


Теперь перед коммитом можно запускать:
npm run lint


Ставь 👍 и забирай 📚 Базу знаний
👍6🤔1
🤔 Что значит type="submit"?

Атрибут type="submit" у тега <button> или <input> указывает, что элемент при нажатии должен отправить форму. Он запускает действие, определенное в action формы, и передаёт данные, собранные с полей.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний
👍8
🤔 Какие преимущества у di?

Dependency Injection (DI) – это паттерн проектирования, который помогает разделять зависимости и делает код гибче, тестируемее и поддерживаемее. Вместо того чтобы создавать зависимости внутри класса, они передаются (инъектируются) извне.

🚩Почему DI полезен?

🟠Уменьшает связность кода (Loose Coupling)
Вместо того чтобы жестко привязывать один модуль к другому, DI передает зависимости снаружи.
class UserService {
constructor() {
this.db = new Database(); // Прямо создаем зависимость
}

getUser(id) {
return this.db.findUserById(id);
}
}


С DI (гибкость)
class UserService {
constructor(db) {
this.db = db; // DI передает зависимость извне
}

getUser(id) {
return this.db.findUserById(id);
}
}

// Передаем нужную зависимость
const database = new Database();
const userService = new UserService(database);


🟠Улучшает тестируемость (Unit-тесты проще)
С DI можно подменять зависимости на заглушки (mock, fake, stub).
const userService = new UserService(); // Всегда использует реальную Database
userService.getUser(1); // Как протестировать без реальной БД? 🤔


С DI (можно подменить зависимость)
class FakeDatabase {
findUserById(id) {
return { id, name: "Тестовый пользователь" };
}
}

const fakeDb = new FakeDatabase();
const userService = new UserService(fakeDb);

console.log(userService.getUser(1)); // Тест без реальной БД


🟠Улучшает расширяемость (легко менять зависимости)
Допустим, сначала использовали MySQLDatabase, но решили перейти на MongoDatabase.
class UserService {
constructor() {
this.db = new MySQLDatabase(); // Нужно менять здесь
}
}


С DI (добавляем новую зависимость без изменения кода UserService)
const db = new MongoDatabase(); // Просто передаем другую зависимость
const userService = new UserService(db);


🟠Упрощает управление зависимостями (через DI-контейнеры)
В крупных приложениях удобно использовать DI-контейнер (например, InversifyJS для JavaScript/TypeScript).
import "reflect-metadata";
import { Container, injectable, inject } from "inversify";

@injectable()
class Database {
findUserById(id) {
return { id, name: "База данных" };
}
}

@injectable()
class UserService {
constructor(@inject(Database) db) {
this.db = db;
}

getUser(id) {
return this.db.findUserById(id);
}
}

// Настраиваем DI-контейнер
const container = new Container();
container.bind(Database).toSelf();
container.bind(UserService).toSelf();

// Получаем объект с нужными зависимостями
const userService = container.get(UserService);
console.log(userService.getUser(1));


Ставь 👍 и забирай 📚 Базу знаний
👍3
🤔 Что делает omit?

omit – это функция, которая удаляет указанные ключи из объекта и возвращает новый объект без этих ключей.

В JavaScript нет встроенного omit, но его можно реализовать с помощью деструктуризации и методов Object.fromEntries() или reduce().

Реализация omit с Object.fromEntries() (современный способ)
function omit(obj, keys) {
return Object.fromEntries(
Object.entries(obj).filter(([key]) => !keys.includes(key))
);
}

const user = { name: "Alice", age: 25, password: "123456" };
const safeUser = omit(user, ["password"]);

console.log(safeUser); // { name: "Alice", age: 25 }


Реализация omit с reduce() (альтернативный способ)
function omit(obj, keys) {
return Object.keys(obj).reduce((acc, key) => {
if (!keys.includes(key)) acc[key] = obj[key];
return acc;
}, {});
}

const data = { a: 1, b: 2, c: 3 };
console.log(omit(data, ["b"])); // { a: 1, c: 3 }


Если используете Lodash, можно просто вызвать
import { omit } from "lodash";

const user = { name: "Alice", age: 25, password: "123456" };
const safeUser = omit(user, ["password"]);

console.log(safeUser); // { name: "Alice", age: 25 }


Ставь 👍 и забирай 📚 Базу знаний
👍5💊3🤔1
🤔 Как изменить стили кнопок с атрибутом disabled?

C атрибутом disabled, используя селекторы атрибутов. Селектор [disabled] позволяет выбрать все элементы, которые имеют этот атрибут, а селектор :disabled позволяет выбрать все элементы, которые находятся в состоянии disabled.

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

🟠Селектора [disabled]
Этот селектор выбирает все элементы, у которых присутствует атрибут disabled.
button[disabled] {
background-color: gray;
color: white;
border: 1px solid #ccc;
cursor: not-allowed; /* Указывает, что элемент недоступен для взаимодействия */
opacity: 0.6; /* Уменьшает непрозрачность */
}


🟠Псевдокласса :disabled
Этот селектор выбирает все элементы, которые находятся в состоянии disabled.
button:disabled {
background-color: gray;
color: white;
border: 1px solid #ccc;
cursor: not-allowed;
opacity: 0.6;
}


🚩Полные примеры

С HTML
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Disabled Button Styling</title>
<link rel="stylesheet" href="styles.css">
</head>
<body>
<button>Active Button</button>
<button disabled>Disabled Button</button>
</body>
</html>


С CSS
/* Стили для активных кнопок */
button {
background-color: blue;
color: white;
border: 1px solid #000;
padding: 10px 20px;
cursor: pointer;
}

/* Стили для кнопок с атрибутом disabled */
button[disabled] {
background-color: gray;
color: white;
border: 1px solid #ccc;
cursor: not-allowed;
opacity: 0.6;
}

/* Альтернативный способ с использованием псевдокласса :disabled */
button:disabled {
background-color: gray;
color: white;
border: 1px solid #ccc;
cursor: not-allowed;
opacity: 0.6;
}


🟠Комбинированный подход
Вы можете комбинировать селекторы атрибутов с другими селекторами для более точного применения стилей.
/* Стили для кнопок с классом .special, которые имеют атрибут disabled */
button.special[disabled] {
background-color: darkgray;
color: black;
border: 1px dashed #999;
cursor: not-allowed;
opacity: 0.7;
}


Ставь 👍 и забирай 📚 Базу знаний
👍3🔥1🤔1💊1
🤔 Зачем нужен Docker?

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


Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний
👍6🔥1🤔1
🤔 Зачем нужен docker?

Это инструмент для создания, развертывания и управления контейнерами. Контейнер – это изолированная среда, которая содержит всё необходимое для работы приложения: код, зависимости, библиотеки, конфигурации.

🚩Почему нужен Docker?

🟠Решает проблему "работает у меня, но не у тебя"
В разных средах могут быть разные версии зависимостей (Node.js, Python, базы данных). С Docker всё упаковано в контейнер, и приложение работает одинаково на любом сервере.

🟠Автоматизирует развертывание
Без Docker развертывание – это настройка сервера, установка зависимостей, конфигурация окружения. С Docker – просто запускаем контейнер.

🟠Легко масштабировать
Docker-контейнеры можно клонировать и запускать на разных серверах (например, в Kubernetes).

🟠Разделяет зависимости
Каждое приложение работает в изолированной среде, и конфликты библиотек исключены.

🟠Работает везде (Windows, Mac, Linux, серверы, облако)
Контейнер можно запустить где угодно, где установлен Docker.

🚩Как работает Docker?

🟠Создаем `Dockerfile` (инструкция для сборки контейнера)
Пример для Node.js-приложения
# Базовый образ с Node.js
FROM node:18

# Устанавливаем рабочую директорию
WORKDIR /app

# Копируем файлы проекта
COPY package.json ./
RUN npm install
COPY . .

# Запускаем приложение
CMD ["node", "server.js"]


Собираем образ Docker (создаем "упакованный" контейнер)
docker build -t my-app .


Запускаем контейнер
docker run -p 3000:3000 my-app


Ставь 👍 и забирай 📚 Базу знаний
👍5
🤔 Чем var отличается от const ?

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

🚩Область видимости (Scope)

🟠Var
Объявления переменных с ее использованием имеют функциональную область видимости (function scope), что означает, что переменная доступна везде в функции, где была объявлена.

🟠Const
Как и let, она имеет блочную область видимости (block scope), ограничивая доступность переменной блоком (например, циклом или условным оператором), в котором была объявлена.

🚩Переназначение и изменение

🟠Var
Переменные, объявленные с помощью нее, могут быть переназначены и изменены. Это означает, что после объявления переменной её можно не только изменить, но и полностью переназначить на другое значение.

🟠Const
Переменные, объявленные с помощью нее, не могут быть переназначены. Однако, если переменная представляет собой объект или массив, её содержимое может быть изменено (например, можно добавить новое свойство в объект или новый элемент в массив). Важно понимать, что const предотвращает переназначение самой переменной, но не защищает содержимое объекта от изменений.

🚩Поднятие (Hoisting)

🟠Var
Переменные, объявленные через нее, поднимаются в начало своей функциональной области видимости перед выполнением кода. Однако до их объявления в коде они будут иметь значение undefined.

🟠Const
Подобно let, ее объявления тоже поднимаются, но доступ к переменной до её объявления в коде приведёт к ошибке ReferenceError. Это явление известно как "временная мертвая зона".

🚩Инициализация

🟠Var
Эти переменные можно объявить без инициализации, и их начальное значение будет undefined.

🟠Const
Эти переменные требуют обязательной инициализации при объявлении. Если попытаться объявить его без инициализации, это приведет к синтаксической ошибке.

var varVariable = 1;
varVariable = 2; // Переназначение возможно


const constVariable = { a: 1 };
constVariable.a = 2; // Изменение содержимого объекта возможно
// constVariable = { b: 3 }; // Переназначение вызовет ошибку


if (true) {
var varScope = "доступна везде в функции";
const constScope = "доступна только в этом блоке";
}
console.log(varScope); // Выведет строку
console.log(constScope); // Ошибка: constScope не определена


Ставь 👍 и забирай 📚 Базу знаний
👍5💊3
🤔 Чем em отличается от rem?

🟠Как работает `em`?
em зависит от размера шрифта родителя (font-size).
.parent {
font-size: 20px;
}

.child {
font-size: 1.5em; /* 1.5 * 20px = 30px */
}


Но если .child вложен в .parent, то он наследует font-size, а его em вычисляется относительно родителя.
.parent {
font-size: 20px;
}

.child {
font-size: 1.5em; /* 30px */
}

.grandchild {
font-size: 2em; /* 2 * 30px = 60px */
}


🟠Как работает `rem`?
rem всегда зависит от font-size у <html>.
html {
font-size: 16px;
}

.container {
font-size: 2rem; /* 2 * 16px = 32px */
}


🟠Когда использовать `em`, а когда `rem`?
Используйте rem, если нужно, чтобы шрифты и размеры были предсказуемыми
Используйте em, если хотите, чтобы элементы зависели от родителя

Ставь 👍 и забирай 📚 Базу знаний
👍4
🤔 Чего стоит и не стоит избегать в оптимизации сайта?

🟠Оптимизация изображений
Сжатие без потери качества: Используйте инструменты, такие как TinyPNG или ImageOptim. Использование современных форматов: WebP и AVIF обеспечивают лучшее сжатие и качество. Lazy Loading: Загружайте изображения по мере их появления в области видимости пользователя.

🟠Минификация и объединение файлов
Минификация: Уменьшайте размеры CSS, JavaScript и HTML-файлов с помощью инструментов, таких как UglifyJS и CSSNano. Объединение: Сокращайте количество HTTP-запросов, объединяя несколько файлов в один.

🟠Использование CDN (Content Delivery Network)
Размещайте копии вашего сайта на серверах по всему миру, чтобы уменьшить задержки для пользователей из разных регионов.

🟠Кэширование
На стороне клиента: Настройте заголовки кэширования HTTP. На стороне сервера: Используйте технологии, такие как Varnish или Nginx.

🟠Асинхронная загрузка и критический CSS
Асинхронная загрузка: Используйте атрибуты async и defer для JavaScript. Критический CSS: Встраивайте важные стили прямо в HTML, чтобы ускорить начальную отрисовку страницы.

🟠Улучшение производительности сервера
Сжатие данных: Включите gzip или Brotli. HTTP/2: Переходите на HTTP/2 для мультиплексирования запросов.

🟠Использование современных технологий
Service Workers: Для офлайн-работы и улучшенного кэширования. Prefetching и Preloading: Предзагрузка и предзапросы ресурсов.

🟠Мониторинг и анализ
Google Lighthouse, PageSpeed Insights: Используйте для анализа производительности. Реальное время: Применяйте Google Analytics, New Relic.

🚩Чего стоит избегать при оптимизации сайта

🟠Избегайте чрезмерной минимизации
Читаемость кода: Минимизация без генерации карт кода (source maps) может усложнить отладку.

🟠Не используйте большие, несжатые изображения
Размер файлов: Это замедляет загрузку и увеличивает потребление трафика пользователем.

🟠Не загружайте все ресурсы сразу
Асинхронная загрузка: Используйте техники lazy loading и асинхронной загрузки.

🟠Не пренебрегайте кэшированием
Отсутствие кэширования: Увеличивает время загрузки для повторных посещений.

🟠Избегайте блокирующих ресурсов
JavaScript и CSS: Не блокируйте рендеринг страницы тяжелыми файлами.

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

🟠Избегайте чрезмерного использования плагинов
Нагрузки: Избыток плагинов может значительно замедлить сайт и создать проблемы с безопасностью.

🟠Не забывайте про оптимизацию для мобильных устройств
Мобильная версия: Сайт должен быть оптимизирован для мобильных пользователей, так как большинство пользователей используют мобильные устройства.

Ставь 👍 и забирай 📚 Базу знаний
🔥3💊2🤔1
🤔 Как уничтожить объект web worker?

В JavaScript, чтобы уничтожить объект Web Worker, необходимо использовать метод terminate(). Этот метод останавливает выполнение worker'а, освобождает связанные с ним ресурсы и завершает его работу. После вызова terminate() объект worker больше не может быть использован.

🚩Зачем уничтожать Web Worker?

Web Worker позволяет выполнять тяжелые операции в фоновом потоке, не блокируя основной поток (UI-поток). Однако, если worker больше не нужен, он продолжает существовать и занимает ресурсы (память, процессорное время). Чтобы избежать утечек памяти и оптимизировать работу приложения, важно уничтожать worker, когда он больше не используется.

🚩Как использовать `terminate()`?

Вы вызываете метод terminate() на экземпляре объекта worker. Это мгновенно останавливает выполнение фонового скрипта.
// Создаем worker
const myWorker = new Worker('worker.js');

// Выполняем какие-то операции через worker
myWorker.postMessage('Hello, worker!');

// Завершаем работу worker, когда он больше не нужен
myWorker.terminate();


🚩Важно помнить

1⃣После вызова terminate() worker полностью уничтожается и больше не может отправлять или получать сообщения.
2⃣Если есть обработчики событий, привязанные к worker (например, onmessage), они автоматически удаляются.
3⃣Доступ к worker после вызова terminate() не приведет к ошибке, но никакие операции через него больше работать не будут.
const worker = new Worker('worker.js');

// Отправляем сообщение
worker.postMessage('Start working');

// Завершаем работу worker
worker.terminate();

// Попытка отправить сообщение после уничтожения worker
worker.postMessage('Will this work?'); // Ничего не произойдет, worker уже завершен


🚩 Когда еще уничтожается worker?

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

Ставь 👍 и забирай 📚 Базу знаний
👍3🔥1
🤔 Расскажи про memo в react

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 нет.
Если компонент рендерится быстро – оптимизация может быть ненужной, а проверка пропсов даже замедлит работу.
Если пропсы часто изменяются – кэширование теряет смысл, так как все равно ререндерится.

Ставь 👍 и забирай 📚 Базу знаний
👍3
🤔 Что такое git-flow?

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

🚩Основные ветки

🟠master
Содержит стабильную версию кода, готовую к выпуску (release).
🟠develop
Основная ветка для разработки, содержит последние изменения кода для следующего выпуска.

🚩Вспомогательные ветки

🟠feature
Для разработки новых функций. Каждая ветка создается для работы над определенной задачей и в конечном итоге сливается с develop.

🟠release
Предназначенные для подготовки новых выпусков продукта. В них может вестись работа по исправлению ошибок, документации и другим задачам, связанным с выпуском. После завершения подготовки ветка release сливается с master и с develop.

🟠hotfix
Для быстрого исправления ошибок в продакшен-версии. Создаются от ветки master, и после исправления сразу же сливаются обратно в master и develop.

Ставь 👍 и забирай 📚 Базу знаний
👍5
🤔 Расскажи про области видимости

В JavaScript область видимости (scope) определяет доступность переменных, функций и объектов в разных частях кода. Это фундаментальная концепция, которая управляет тем, какие данные могут быть доступны или недоступны в различных частях программы.

🚩Глобальная область видимости

Переменные и функции, объявленные вне любых функций или блоков, находятся в глобальной области видимости. Они доступны из любой части программы.
var globalVar = 'Я глобальная переменная';

function testFunction() {
console.log(globalVar); // Доступно
}

testFunction();
console.log(globalVar); // Доступно


🚩Функциональная область видимости

Переменные, объявленные с помощью var внутри функции, имеют область видимости, ограниченную этой функцией. Они недоступны за её пределами.
function testFunction() {
var functionVar = 'Я внутри функции';
console.log(functionVar); // Доступно
}

testFunction();
console.log(functionVar); // Ошибка: переменная functionVar недоступна


🚩Блочная область видимости

Переменные, объявленные с помощью let и const, имеют область видимости, ограниченную ближайшим блоком {}.
if (true) {
let blockVar = 'Я внутри блока';
console.log(blockVar); // Доступно
}

console.log(blockVar); // Ошибка: переменная blockVar недоступна


🚩Область видимости модуля (Module Scope)

При использовании модулей (например, import и export в ES6), все переменные и функции в модуле имеют собственную область видимости. Они не попадают в глобальную область видимости.
export const myVar = 'Я переменная из модуля';


import { myVar } from './module1.js';
console.log(myVar); // "Я переменная из модуля"


Ставь 👍 и забирай 📚 Базу знаний
👍5
Please open Telegram to view this post
VIEW IN TELEGRAM
🤔 Какая основная причина для использования SSR?

SSR (Server-Side Rendering):
- Улучшает скорость загрузки первого экрана (первая отрисовка приходит сразу с сервера).
- Обеспечивает SEO-оптимизацию, поскольку поисковики получают готовый HTML.
- Полезен для динамического контента, где важна предзагрузка.


Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний
🔥4👍2
Please open Telegram to view this post
VIEW IN TELEGRAM
🤔 Когда стоит использовать тип any?

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

🚩Если тип данных неизвестен заранее (например, ответ от API)
Иногда сервер может вернуть разные структуры данных, и невозможно заранее определить точный тип.
async function fetchData(url: string): Promise<any> {
const response = await fetch(url);
return response.json();
}


Лучший вариант — использовать интерфейсы вместо any:
interface User {
id: number;
name: string;
}

async function fetchUser(url: string): Promise<User> {
const response = await fetch(url);
return response.json() as User;
}


🚩При миграции JavaScript в TypeScript

Если проект на чистом JavaScript, добавление TypeScript может сломать код. any помогает постепенно вводить строгую типизацию.
function log(value: any) {
console.log(value);
}


🚩Когда работаем с динамическими структурами (например, `localStorage`)

В localStorage можно сохранить что угодно, поэтому при чтении данных тип неизвестен.
const data: any = localStorage.getItem("user");


Лучше сразу привести any к нужному типу
const user = JSON.parse(localStorage.getItem("user") || "{}") as { id: number; name: string };


🚩Когда пишем универсальную библиотеку

Если функция должна работать с разными типами, any может быть временным решением.
function mergeObjects(obj1: any, obj2: any): any {
return { ...obj1, ...obj2 };
}


Лучший вариант с generic (T вместо any)
function mergeObjects<T, U>(obj1: T, obj2: U): T & U {
return { ...obj1, ...obj2 };
}


Ставь 👍 и забирай 📚 Базу знаний
💊2👍1