Frontend | Вопросы собесов
19.3K subscribers
33 photos
1 video
912 links
Download Telegram
📌 Вопрос из таблицы?

💬 Спрашивают в ЦИФРА% собеседований

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

1️⃣ Клиент-серверные приложения

🤔 Веб-приложения (JavaScript/TypeScript)

Для веб-приложений запросы к серверу обычно выполняются на стороне клиента (в браузере) с использованием JavaScript или TypeScript. Чаще всего это делается с помощью API, таких как fetch или axios.

Пример с использованием fetch:
function fetchData() {
fetch('https://api.example.com/data')
.then(response => response.json())
.then(data => {
console.log(data);
})
.catch(error => {
console.error('Error:', error);
});
}


🤔 Веб-приложения с использованием библиотек/фреймворков

Когда вы используете фреймворки, такие как React, Angular или Vue, запросы к серверу обычно выполняются в компонентах или сервисах.

Пример с использованием React:
import React, { useEffect, useState } from 'react';

function MyComponent() {
const [data, setData] = useState(null);

useEffect(() => {
fetch('https://api.example.com/data')
.then(response => response.json())
.then(data => setData(data))
.catch(error => console.error('Error:', error));
}, []);

return (
<div>
{data ? <div>Data: {data}</div> : <div>Loading...</div>}
</div>
);
}


🤔 Мобильные приложения

Для мобильных приложений, разработанных с использованием таких технологий, как React Native, Swift или Kotlin, запросы к серверу также выполняются в коде приложения.

Пример с использованием React Native:
import React, { useEffect, useState } from 'react';
import { View, Text } from 'react-native';

function MyComponent() {
const [data, setData] = useState(null);

useEffect(() => {
fetch('https://api.example.com/data')
.then(response => response.json())
.then(data => setData(data))
.catch(error => console.error('Error:', error));
}, []);

return (
<View>
{data ? <Text>Data: {data}</Text> : <Text>Loading...</Text>}
</View>
);
}


2️⃣ Серверные приложения

🤔 Серверные скрипты (Node.js)

В случае серверных приложений на Node.js запросы к другим серверам могут выполняться для интеграции с внешними API или микросервисами.

Пример с использованием axios:
const axios = require('axios');

axios.get('https://api.example.com/data')
.then(response => {
console.log(response.data);
})
.catch(error => {
console.error('Error:', error);
});


🤔 Бэкенд-фреймворки (Django, Flask)

В бэкенд-фреймворках, таких как Django или Flask, запросы к другим серверам часто выполняются в функциях обработки запросов (view-функциях) или в бизнес-логике приложения.

Пример с использованием Django (Python):
import requests
from django.http import JsonResponse

def fetch_data(request):
response = requests.get('https://api.example.com/data')
if response.status_code == 200:
return JsonResponse(response.json())
else:
return JsonResponse({'error': 'Failed to fetch data'}, status=response.status_code)


🤔 Заключение

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

🤔 Краткое объяснение

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

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых
Please open Telegram to view this post
VIEW IN TELEGRAM
👍162🔥1
Что такое hoisting ?
Спросят с вероятностью 7%

Поднятие (hoisting) — это механизм, при котором объявления переменных и функций поднимаются вверх своей области видимости во время компиляции, до фактического выполнения кода. Это означает, что вы можете использовать переменные и функции до их объявления в коде.

Hoisting переменных

Для переменных, объявленных с использованием var, только само объявление поднимается, а присвоение значения остается на своем месте. Это может привести к неожиданным результатам.
console.log(a); // undefined
var a = 5;
console.log(a); // 5

Интерпретируется как:
var a;
console.log(a); // undefined
a = 5;
console.log(a); // 5


Переменные, объявленные с помощью let и const, также поднимаются, но находятся в так называемой "временной мертвой зоне" (temporal dead zone, TDZ) до тех пор, пока выполнение кода не дойдет до строки их объявления. Попытка доступа к таким переменным до их объявления вызывает ошибку.
console.log(b); // ReferenceError: Cannot access 'b' before initialization
let b = 10;
console.log(b); // 10

console.log(c); // ReferenceError: Cannot access 'c' before initialization
const c = 15;
console.log(c); // 15


Hoisting функций

Функции, объявленные с помощью function declaration, полностью поднимаются — как объявление, так и их определение. Это позволяет вызывать функции до их объявления в коде.
hoistedFunction(); // "This function is hoisted"

function hoistedFunction() {
console.log("This function is hoisted");
}


Функции, объявленные как function expression, ведут себя иначе. Только объявление переменной поднимается, но не ее присвоение. Это значит, что вы не можете вызвать такую функцию до ее фактического объявления.
hoistedFunctionExpression(); // TypeError: hoistedFunctionExpression is not a function

var hoistedFunctionExpression = function() {
console.log("This function is not hoisted");
};


Важные моменты

1️⃣Переменные, объявленные с помощью `var`, поднимаются, но их значение становится undefined до присвоения.
2️⃣Переменные, объявленные с помощью let ито такое поднимаются, но остаются недоступными до фактического объявления в коде, что вызывает ошибку при доступе.
3️⃣Функции, объявленные как function declaration, полностью поднимаются и могут быть вызваны до своего объявления.
4️⃣Функции, объявленные как function expression, поднимаются только как переменные, а присвоение происходит на месте, что делает их недоступными до присвоения.

Поднятие (hoisting) — это механизм, при котором объявления переменных и функций поднимаются вверх своей области видимости во время компиляции, позволяя использовать их до фактического объявления в коде. Однако, переменные, объявленные с let и const, остаются недоступными до их фактического объявления.

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

🔐 База собесов | 🔐 База тестовых
👍305
Что такое merge и rebase, в чем отличие друг от друга ?
Спросят с вероятностью 7%

merge и rebase — это два способа интеграции изменений из одной ветки в другую в системе контроля версий Git. Оба метода имеют свои особенности и подходят для разных сценариев.

Merge (слияние)

Объединяет изменения из одной ветки в другую, создавая новый коммит слияния (merge commit). Этот метод сохраняет историю всех коммитов, включая все ветвления и слияния.

1️⃣Предположим, у вас есть две ветки: main и feature.
2️⃣В ветке feature вы сделали несколько коммитов.
3️⃣Вы хотите объединить изменения из feature в main.
git checkout main
git merge feature


В результате получается история, включающая коммит слияния:
A---B---C---F---G (main)
\ /
D---E (feature)


Где F и G — коммиты в ветке main, а D и E — коммиты в ветке feature. Коммит G — это коммит слияния, который объединяет изменения из feature в main.

Rebase (перебазирование)

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

1️⃣Предположим, у вас есть две ветки: main и feature.
1️⃣В ветке feature вы сделали несколько коммитов.
3️⃣Вы хотите перенести изменения из feature на текущий конец main.
git checkout feature
git rebase main


В результате история переписывается, как если бы коммиты из feature были сделаны на основе самой свежей версии main:
A---B---C---F---G (main)
\
D'---E' (feature)


Где D' и E' — это новые коммиты, созданные при перебазировании, основанные на последних изменениях из main.

Основные отличия

1️⃣История коммитов:
Merge: Сохраняет всю историю, включая коммиты слияния. История показывает, когда и как происходили слияния веток.
Rebase: Переписывает историю, делая её линейной. История показывает, как если бы все изменения были сделаны последовательно, без ветвлений.

2️⃣Коммиты слияния:
Merge: Создает новый коммит слияния, который объединяет изменения из двух веток.
Rebase: Не создает коммит слияния. Перебазирование "переносит" коммиты одной ветки на другую.

3️⃣Конфликты:
Merge: Конфликты решаются один раз при слиянии.
Rebase: Конфликты могут возникнуть на каждом коммите, и их нужно решать поэтапно.

4️⃣Применение:
Merge: Хорош для сохранения полного контекста истории разработки, особенно в командной работе.
Rebase: Хорош для поддержания чистой, линейной истории, особенно перед слиянием ветки в основную ветку, например, main или master.

Когда использовать

Используйте `merge`, когда вы хотите сохранить всю историю разработки, включая все ветвления и слияния. Это полезно для командной работы, где важно видеть весь контекст изменений.
Используйте rebase, когда вы хотите поддерживать чистую и линейную историю. Это особенно полезно для интеграции изменений в основную ветку перед созданием pull request'ов, чтобы история коммитов была более понятной.

Merge объединяет изменения из одной ветки в другую, создавая новый коммит слияния и сохраняя всю историю. Rebase переписывает историю, делая её линейной, перемещая коммиты из одной ветки на базу другой.

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

🔐 База собесов | 🔐 База тестовых
👍32🔥7🤯31
Что такое dns ?
Спросят с вероятностью 3%

DNS (Domain Name System) — это система, которая переводит доменные имена, понятные человеку, в IP-адреса, понятные компьютерам и сетевым устройствам. Основная задача DNS — облегчить доступ к ресурсам в Интернете, позволяя использовать легко запоминаемые доменные имена вместо сложных числовых IP-адресов.

Основные функции

1️⃣Разрешение доменных имен:
Основная функция DNS заключается в преобразовании доменных имен (например, www.example.com) в соответствующие им IP-адреса (например, 93.184.216.34), чтобы веб-браузеры и другие интернет-клиенты могли находить и обращаться к нужным ресурсам.

2️⃣Обратное разрешение (Reverse DNS):
Обратное разрешение — это процесс преобразования IP-адресов обратно в доменные имена. Это используется для проверки подлинности или при проведении сетевой диагностики.

Как он работает

Процесс разрешения доменного имени включает несколько этапов и компонентов:

1️⃣Введение DNS-кэша:
Браузер и операционная система сначала проверяют свои локальные кэши на наличие записи о недавно разрешенном доменном имени. Если запись найдена и не истекла, используется закэшированный IP-адрес.

2️⃣Запрос к DNS-серверу:
Если локальный кэш не содержит нужной записи, запрос отправляется к DNS-серверу вашего интернет-провайдера (ISP) или другого конфигурируемого DNS-сервера (например, Google Public DNS).

3️⃣Рекурсивный запрос:
DNS-сервер провайдера может выполнять рекурсивный запрос, запрашивая информацию у других DNS-серверов, если он сам не знает ответа. Этот процесс включает несколько шагов:
Запрос к корневому DNS-серверу.
Корневой сервер направляет к DNS-серверу верхнего уровня домена (TLD, например, .com, .org).
Сервер верхнего уровня направляет к авторитетному DNS-серверу конкретного домена.

4️⃣Авторитетные DNS-серверы:
Авторитетный DNS-сервер для домена (например, example.com) содержит окончательную информацию об IP-адресе для запрашиваемого доменного имени и возвращает её DNS-серверу провайдера.

5️⃣Ответ клиенту:
DNS-сервер провайдера кэширует полученный IP-адрес и отправляет его обратно клиенту (вашему браузеру или операционной системе).

6️⃣Доступ к ресурсу:
Клиент использует полученный IP-адрес для установления соединения с нужным сервером и получения запрашиваемых данных.

Допустим, вы вводите в браузере www.example.com:

1️⃣Браузер проверяет локальный DNS-кэш.
2️⃣Если записи нет, браузер отправляет запрос на DNS-сервер провайдера.
3️⃣DNS-сервер провайдера выполняет рекурсивный запрос:
Запрашивает корневой DNS-сервер.
Корневой сервер направляет к серверу TLD .com.
Сервер TLD направляет к авторитетному DNS-серверу example.com.
4️⃣Авторитетный DNS-сервер example.com возвращает IP-адрес, например, 93.184.216.34.
5️⃣DNS-сервер провайдера кэширует этот IP-адрес и возвращает его браузеру.
6️⃣Браузер устанавливает соединение с сервером по IP-адресу 93.184.216.34 и загружает страницу.

DNS (Domain Name System) — это система, которая преобразует доменные имена в IP-адреса и наоборот. Она позволяет пользователям вводить легко запоминаемые доменные имена вместо сложных IP-адресов для доступа к ресурсам в Интернете. DNS включает в себя процессы проверки кэша, рекурсивные запросы к DNS-серверам и использование различных типов записей для разрешения имен и управления ресурсами.

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

🔐 База собесов | 🔐 База тестовых
👍332
Какие особенности в js ?
Спросят с вероятностью 3%

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

1️⃣Динамическая типизация

Является языком с динамической типизацией, что означает, что тип переменной определяется во время выполнения, а не во время компиляции. Тип переменной может изменяться в процессе выполнения программы.
let variable = 42; // Число
variable = 'Hello, world!'; // Строка


2️⃣Функции первого класса

Являются объектами первого класса, что означает, что функции могут быть присвоены переменным, переданы как аргументы другим функциям и возвращены из других функций.
function greet(name) {
return `Hello, ${name}`;
}

const sayHello = greet;
console.log(sayHello('Alice')); // Hello, Alice

function executeFunction(fn, value) {
return fn(value);
}

console.log(executeFunction(greet, 'Bob')); // Hello, Bob


3️⃣Замыкания (Closures)

Это функции, которые имеют доступ к переменным из своей внешней функции даже после того, как внешняя функция завершила выполнение. Это позволяет создавать функции с привязанными к ним переменными из внешнего окружения.
function createCounter() {
let count = 0;
return function() {
count++;
return count;
};
}

const counter = createCounter();
console.log(counter()); // 1
console.log(counter()); // 2


4️⃣Прототипное наследование

Использует прототипное наследование вместо классового. Каждый объект в JavaScript имеет скрытое свойство [[Prototype]], которое указывает на другой объект, используемый в качестве прототипа.
const animal = {
speak: function() {
console.log(`${this.name} издает звук`);
}
};

const dog = Object.create(animal);
dog.name = 'Рекс';
dog.speak(); // Рекс издает звук


5️⃣Асинхронность и события

Поддерживает асинхронное выполнение через коллбеки, промисы и async/await. Это позволяет обрабатывать события и операции ввода-вывода без блокировки основного потока выполнения.

Использование коллбеков:
function fetchData(callback) {
setTimeout(() => {
callback('Данные получены');
}, 1000);
}

fetchData((data) => {
console.log(data); // Данные получены (через 1 секунду)
});


Использование промисов:
function fetchData() {
return new Promise((resolve, reject) => {
setTimeout(() => {
resolve('Данные получены');
}, 1000);
});
}

fetchData().then(data => {
console.log(data); // Данные получены (через 1 секунду)
});


Использование async/await:
async function fetchData() {
return new Promise((resolve, reject) => {
setTimeout(() => {
resolve('Данные получены');
}, 1000);
});
}

async function getData() {
const data = await fetchData();
console.log(data); // Данные получены (через 1 секунду)
}

getData();


6️⃣Интуитивно понятная работа с объектами

Имеет мощные встроенные функции для работы с объектами, такие как деструктуризация, операторы расширения и методы объектов.

Деструктуризация:
const person = {
name: 'Alice',
age: 30
};

const { name, age } = person;
console.log(name); // Alice
console.log(age); // 30


Операторы расширения:
const obj1 = { a: 1, b: 2 };
const obj2 = { b: 3, c: 4 };
const mergedObj = { ...obj1, ...obj2 };

console.log(mergedObj); // { a: 1, b: 3, c: 4 }


Обладает множеством уникальных особенностей, таких как динамическая типизация, функции первого класса, замыкания, прототипное наследование, асинхронное программирование с коллбеками, промисами и async/await, интуитивно понятная работа с объектами и массивами, а также событийно-ориентированное программирование. Эти возможности делают его мощным и гибким инструментом для веб-разработки и других приложений.

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

🔐 База собесов | 🔐 База тестовых
👍314🤔3
🤔 Какой тип CSS-свойства background-clip определяет, что фон будет ограничен контентом элемента?
Anonymous Quiz
26%
border-box
3%
padding-box
70%
content-box
2%
margin-box
👍13
📌 Зачем создавались библиотеки react и другие?

💬 Спрашивают в 3% собеседований

Библиотеки, такие как React, создавались для упрощения и оптимизации процесса разработки пользовательских интерфейсов (UI). Вот несколько ключевых причин, почему создавались React и другие библиотеки:

1️⃣ Повышение эффективности разработки

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

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

2️⃣ Улучшение производительности

Проблема: Постоянное обновление DOM (Document Object Model) может быть медленным и ресурсоемким.

Решение: React использует виртуальный DOM, который минимизирует количество реальных изменений в DOM, обновляя только те элементы, которые действительно изменились.

3️⃣ Облегчение работы с состоянием приложения

Проблема: Управление состоянием больших и сложных приложений может стать хаотичным.

Решение: React предоставляет механизмы для удобного управления состоянием компонентов с помощью useState, useReducer, и других хуков. Это делает логику управления состоянием более ясной и предсказуемой.

4️⃣ Улучшение масштабируемости и поддерживаемости кода

Проблема: По мере роста приложения, код может стать сложным для понимания и изменения.

Решение: Подход к компонентам в React позволяет разработчикам легче разделять задачи и работать над отдельными частями приложения независимо друг от друга. Это улучшает масштабируемость и поддерживаемость кода.

5️⃣ Сообщество и экосистема

Проблема: Наличие обширного сообщества и инструментов для разработки.

Решение: React имеет большое сообщество разработчиков, множество библиотек и инструментов, которые упрощают разработку и интеграцию различных функций в приложения.

Пример использования React:
import React, { useState } from 'react';

function Counter() {
// Определение состояния count с начальным значением 0
const [count, setCount] = useState(0);

return (
<div>
<p>Вы кликнули {count} раз(а)</p>
<button onClick={() => setCount(count + 1)}>
Кликни меня
</button>
</div>
);
}

export default Counter;


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

🤔 Краткий ответ

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

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых
Please open Telegram to view this post
VIEW IN TELEGRAM
👍232🔥2
🤔 Какой метод JavaScript используется для удаления первого элемента из массива?
Anonymous Quiz
3%
push()
20%
pop()
49%
shift()
28%
unshift()
👍18
📌 Какие минусы у React?

💬 Спрашивают в 3% собеседований

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

1️⃣ Крутая кривая обучения

Проблема: Для новых разработчиков React может показаться сложным из-за концепций, таких как JSX, компоненты, хуки и управление состоянием.

Последствия: Требуется время и усилия для освоения всех особенностей и возможностей библиотеки.

2️⃣ Быстрая эволюция

Проблема: React и его экосистема развиваются очень быстро, часто выходят новые версии и дополнительные библиотеки.

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

3️⃣ Неисчерпывающая документация для продвинутых тем

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

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

4️⃣ Ограниченные возможности для SEO

Проблема: Приложения на React рендерятся на стороне клиента, что может ухудшить индексацию страниц поисковыми системами.

Последствия: Требуется дополнительная настройка, например, использование серверного рендеринга (Next.js), для улучшения SEO.

5️⃣ Сложность в конфигурировании и настройке

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

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

6️⃣ Производительность при большом количестве компонентов

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

Последствия: Требуется оптимизация кода и использование таких инструментов, как мемоизация (React.iss.onemo, хуки useMemo и useCallback), чтобы избежать ненужных перерисовок.

🤔 Пример проблемы с производительностью:
import React, { useState, useMemo } from 'react';

function ExpensiveComponent({ num }) {
const computedValue = useMemo(() => {
let sum = 0;
for (let i = 0; i < num * 1000; i++) {
sum += i;
}
return sum;
}, [num]);

return <div>Computed Value: {computedValue}</div>;
}

function App() {
const [num, setNum] = useState(1);

return (
<div>
<button onClick={() => setNum(num + 1)}>Increase</button>
<ExpensiveComponent num={num} />
</div>
);
}

export default App;


В этом примере показана оптимизация вычислений с использованием useMemo.

🤔 Краткий ответ

Минусы React: сложность обучения, быстрая эволюция, недостаток продвинутой документации, ограниченные возможности SEO, сложность конфигурации и возможные проблемы с производительностью при большом количестве компонентов.

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых
Please open Telegram to view this post
VIEW IN TELEGRAM
👍238
📌 Как часто происходит рендер?

💬 Спрашивают в 3% собеседований

В React рендеринг компонента происходит в нескольких ситуациях. Давайте рассмотрим основные из них:

1️⃣ Первоначальный рендеринг:

Когда компонент впервые монтируется в DOM.

2️⃣ Обновление состояния (state):

Если состояние компонента изменяется с помощью this.setState в классовых компонентах или useState в функциональных компонентах.

3️⃣ Обновление пропсов (props):

Когда компонент получает новые пропсы от родительского компонента.

4️⃣ Обновление контекста (context):

Когда значение контекста, используемого компонентом, изменяется.

5️⃣ Обновление при изменении ключа (key):

Если ключ компонента изменяется (например, в списках), React будет рассматривать это как удаление старого компонента и добавление нового.

Теперь разберём каждый случай подробнее:

1️⃣ Первоначальный рендеринг

Когда компонент впервые добавляется в DOM, происходит его рендеринг. Это единственный раз, когда компонент рендерится в процессе монтирования.

Пример:
function App() {
return <MyComponent />;
}


2️⃣. Обновление состояния

Когда состояние компонента изменяется, React вызывает рендеринг компонента. Это позволяет компоненту отобразить новые данные.

Пример:
function MyComponent() {
const [count, setCount] = useState(0);

return (
<div>
<p>{count}</p>
<button onClick={() => setCount(count + 1)}>Increment</button>
</div>
);
}


3️⃣ Обновление пропсов

Если родительский компонент передаёт новые пропсы, дочерний компонент будет ререндериться с новыми данными.

Пример:
function ParentComponent() {
const [value, setValue] = useState(0);

return (
<div>
<button onClick={() => setValue(value + 1)}>Change Value</button>
<ChildComponent value={value} />
</div>
);
}

function ChildComponent({ value }) {
return <p>{value}</p>;
}


4️⃣ Обновление контекста

Когда значение контекста изменяется, все компоненты, использующие этот контекст, будут ререндериться.

Пример:
const MyContext = React.createContext();

function App() {
const [value, setValue] = useState('initial');

return (
<MyContext.Provider value={value}>
<button onClick={() => setValue('updated')}>Update Context</button>
<MyComponent />
</MyContext.Provider>
);
}

function MyComponent() {
const contextValue = useContext(MyContext);
return <p>{contextValue}</p>;
}


5️⃣ Обновление при изменении ключа

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

Пример:
function App() {
const [items, setItems] = useState([1, 2, 3]);

return (
<ul>
{items.map(item => (
<li key={item}>{item}</li>
))}
<button onClick={() => setItems([4, 5, 6])}>Change Items</button>
</ul>
);
}


🤔 Оптимизация рендеринга

Чтобы уменьшить количество ненужных рендеров, можно использовать:

PureComponent и React.iss.onemo для функциональных компонентов.
shouldComponentUpdate для классовых компонентов.
useMemo и useCallback для мемоизации значений и функций в функциональных компонентах.

🤔 Резюме:
Компоненты React рендерятся при первоначальном монтировании, изменении состояния, изменении пропсов, изменении контекста и изменении ключа. Оптимизация рендеринга может быть достигнута с помощью PureComponent, React.iss.onemo, shouldComponentUpdate, useMemo и useCallback.

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых
Please open Telegram to view this post
VIEW IN TELEGRAM
👍304🔥4
🤔 Какой метод JavaScript используется для поиска всех элементов по имени класса?
Anonymous Quiz
23%
document.querySelector()
2%
document.getElementById()
73%
document.getElementsByClassName()
2%
document.find()
👍16
📌 Как браузер обрабатывает ссылки?

💬 Спрашивают в 3% собеседований

Браузер обрабатывает ссылки (теги <a>) следующим образом:

🤔 Основные этапы обработки ссылки браузером:

1️⃣ Рендеринг HTML:

Когда браузер загружает HTML-документ, он разбирает его и создает DOM (Document Object Model). В этом процессе браузер встречает тег <a> и определяет, что это ссылка.

2️⃣ Наведение и щелчок по ссылке:

Когда пользователь наводит курсор на ссылку, браузер может показать URL в строке состояния или всплывающем окне.

При щелчке по ссылке браузер проверяет атрибуты ссылки (href, target, и др.), чтобы определить, как обработать этот клик.

3️⃣ Проверка атрибута `href`:

Если href отсутствует или равно #, браузер не будет переходить на другую страницу.

Если href содержит URL, браузер начинает процесс навигации.

4️⃣ Обработка атрибута `target`:

Если target установлен в _self или не указан, браузер загружает новую страницу в текущем окне.

Если target установлен в _blank, браузер открывает новую страницу в новой вкладке или окне.

Если указано имя фрейма, браузер попытается загрузить новую страницу в указанный фрейм.

5️⃣ Выполнение возможных JavaScript обработчиков событий:

Браузер проверяет наличие событий, таких как onclick, onmousedown, onmouseup и т.д.

Если обработчик события вызвал event.preventDefault(), переход на новую страницу не произойдет.

6️⃣ Отправка HTTP-запроса:

Браузер отправляет HTTP-запрос к серверу, если ссылка ведет на другой ресурс.

Сервер обрабатывает запрос и отправляет ответ.

7️⃣ Обработка ответа от сервера:

Если ответ сервера содержит HTML, браузер начнет разбор нового HTML-документа.

Если ответ сервера является перенаправлением (статусы 3xx), браузер отправит новый запрос по указанному адресу.

Если ответ сервера является ошибкой (статусы 4xx или 5xx), браузер отобразит страницу ошибки.

8️⃣ Загрузка ресурсов:

После получения нового HTML-документа браузер загружает все связанные ресурсы (CSS, JS, изображения и т.д.).

9️⃣ Отображение новой страницы:

Браузер обновляет DOM и перерисовывает страницу, отображая новый контент пользователю.

🤔 Пример работы с ссылкой

HTML:
<a href="https://example.com" target="_blank" id="myLink">Перейти на example.com</a>


JavaScript:
document.getElementById('myLink').addEventListener('click', function(event) {
event.preventDefault();
console.log('Ссылка была нажата, но переход не произошел');
// Можно выполнить дополнительную логику здесь
});


🤔 Атрибуты ссылки и их значение

`href`: определяет URL, на который ведет ссылка.

`target`: определяет, где открыть связанный документ.

_self: в текущем окне/вкладке.

_blank: в новом окне/вкладке.

_parent: в родительском фрейме.

_top: во всем текущем окне.

`rel`: определяет отношения между текущим документом и связанным документом. Полезно для SEO и безопасности (например, rel="noopener noreferrer" для ссылок с target="_blank").

🤔 Резюме

Когда вы нажимаете на ссылку, браузер проверяет её атрибуты (href, target и другие), может выполнить JavaScript-обработчики событий, отправляет HTTP-запрос, обрабатывает ответ от сервера и отображает новую страницу.


🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых
Please open Telegram to view this post
VIEW IN TELEGRAM
👍266
🤔 Какой атрибут у тега <input> указывает, что поле должно быть автоматически сфокусировано при загрузке страницы
Anonymous Quiz
52%
autofocus
39%
focus
4%
auto
5%
onload
👍11
📌 Что такое доступность интерфейсов?

💬 Спрашивают в 3% собеседований

Доступность интерфейсов (или веб-доступность, англ. web accessibility) — это практика создания веб-сайтов и приложений, которые могут быть использованы всеми людьми, включая людей с ограниченными возможностями. Цель доступности — сделать так, чтобы любой пользователь, независимо от его физических или когнитивных особенностей, мог получить доступ к контенту и функциональности веб-ресурса.

🤔 Зачем нужна доступность

1️⃣ Социальная значимость:

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

Это способствует социальному включению и поддерживает права всех людей на доступ к информации и услугам.

2️⃣ Юридические требования:

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

Несоблюдение этих требований может привести к юридическим последствиям и штрафам.

3️⃣ Расширение аудитории:

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

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

🤔 Основные принципы доступности

1️⃣ Воспринимаемость (Perceivable):

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

Пример: использование альтернативного текста (alt) для изображений, чтобы они могли быть восприняты пользователями экранных читалок.

2️⃣ Управляемость (Operable):

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

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

3️⃣ Понимаемость (Understandable):

Информация и управление интерфейсом должны быть понятными.

Пример: использование простого и понятного языка, предсказуемое поведение интерфейсов.

4️⃣ Надежность (Robust):

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

Пример: использование семантически правильного HTML-кода.

🤔 Примеры улучшений доступности

1️⃣ Альтернативный текст для изображений:
   <img src="example.jpg" alt="Описание изображения">


2️⃣ Подписи и описания для форм:
   <label for="username">Имя пользователя:</label>
<input type="text" id="username" name="username">


3️⃣ Доступная навигация:
- Обеспечение возможности перемещения по странице с помощью клавиши Tab и указание фокуса для элементов.
   :focus {
outline: 2px solid blue;
}


4️⃣ Использование ARIA (Accessible Rich Internet Applications):
- ARIA атрибуты помогают сделать сложные веб-приложения доступными.
   <button aria-label="Закрыть меню">X</button>


🤔 Инструменты и ресурсы для проверки доступности

1️⃣ Screen readers (экранные читалки):

JAWS, NVDA, VoiceOver — программы, которые озвучивают содержимое экрана и помогают пользователям с нарушением зрения.

2️⃣ Линтеры и валидаторы:

WAVE (Web Accessibility Evaluation Tool), Axe, Lighthouse — инструменты для автоматической проверки доступности веб-страниц.

3️⃣ Руководства и стандарты:

WCAG (Web Content Accessibility Guidelines) — международные рекомендации по обеспечению доступности веб-контента.

🤔 Резюме

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

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых
Please open Telegram to view this post
VIEW IN TELEGRAM
👍14🔥31
🤔 Какой метод JavaScript позволяет проверить, содержит ли элемент указанный класс?
Anonymous Quiz
29%
hasClass()
10%
containsClass()
8%
getClass()
54%
classList.contains()
👍14🤔2
📌 Как происходит отрисовка сайта для пользователя?

💬 Спрашивают в 3% собеседований

Отрисовка сайта для пользователя включает несколько этапов. Давайте разберём их подробнее.

1️⃣ Запрос к серверу:

Когда пользователь вводит URL-адрес в браузере и нажимает Enter, браузер отправляет HTTP-запрос к серверу, где находится сайт.

2️⃣ Ответ сервера:

Сервер получает запрос и отправляет обратно нужные файлы. Обычно это HTML-документ, стили (CSS) и скрипты (JavaScript).

3️⃣ Парсинг HTML:

Браузер начинает читать (парсить) HTML-документ. Он строит дерево DOM (Document Object Model), которое представляет структуру HTML. Каждый элемент HTML становится узлом в этом дереве.

4️⃣ Загрузка и применение CSS:

После парсинга HTML браузер загружает и применяет стили из CSS-файлов. Это позволяет создать дерево CSSOM (CSS Object Model), которое описывает, как каждый элемент должен выглядеть. Затем DOM и CSSOM объединяются, чтобы создать render tree (дерево рендеринга).

5️⃣ Загрузка и выполнение JavaScript:

Когда браузер находит теги <script>, он загружает и выполняет JavaScript. Скрипты могут изменять DOM, что потребует обновления render tree. JavaScript может также изменять CSSOM и запрашивать новые данные с сервера (например, с помощью AJAX).

6️⃣ Отрисовка (рендеринг):
На основе render tree браузер рассчитывает расположение каждого элемента (layout) и отрисовывает (paint) их на экране. Этот процесс называется layout и painting.

7️⃣ Оптимизации и обновления:

Браузеры используют различные оптимизации, такие как кэширование ресурсов, асинхронную загрузку скриптов и отложенную загрузку изображений. JavaScript и CSS могут вызывать изменения в DOM, которые требуют перерисовки (repaint) или перерасчета расположения элементов (reflow).

🤔 Пример:

<!DOCTYPE html>
<html lang="ru">
<head>
<meta charset="UTF-8">
<title>Мой Сайт</title>
<link rel="stylesheet" href="styles.css">
</head>
<body>
<h1>Привет, мир!</h1>
<p>Это пример простого HTML-документа.</p>
<script src="script.js"></script>
</body>
</html>


В этом примере браузер сначала загрузит HTML, создаст DOM, затем загрузит CSS и создаст CSSOM, а потом загрузит и выполнит JavaScript.

🤔 **Вкратце**: Браузер загружает HTML, CSS и JavaScript с сервера, создаёт внутренние структуры данных (DOM и CSSOM), рассчитывает расположение элементов и отрисовывает их на экране пользователя.

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых
Please open Telegram to view this post
VIEW IN TELEGRAM
👍251🤯1
📌 Как строки кода преобразуются в сайт?

💬 Спрашивают в 3% собеседований

Преобразование строк кода в сайт включает несколько ключевых этапов. Рассмотрим этот процесс подробно.

1️⃣ Получение исходного кода:

Когда вы создаете сайт, вы пишете исходный код на языках HTML, CSS и JavaScript. Этот код хранится на сервере, готовый для отправки пользователю по запросу.

2️⃣ Запрос к серверу и ответ:

Когда пользователь вводит URL в браузере, браузер отправляет HTTP-запрос к серверу. Сервер отвечает, отправляя обратно файлы с кодом.

3️⃣ Парсинг HTML:

Браузер начинает анализировать HTML-документ. Он считывает строки HTML-кода и строит дерево DOM (Document Object Model). DOM представляет собой иерархическую структуру всех элементов на странице.

4️⃣ Загрузка и парсинг CSS:

При обнаружении ссылок на CSS-файлы в HTML (тег <link>), браузер загружает эти файлы и анализирует их, создавая CSSOM (CSS Object Model). CSSOM описывает стили и правила для каждого элемента на странице.

5️⃣ Создание дерева рендеринга:

После создания DOM и CSSOM, браузер объединяет их в дерево рендеринга. Это дерево определяет, как элементы будут отображаться на странице, с учетом всех стилей и разметки.

6️⃣ Загрузка и выполнение JavaScript:

Когда браузер встречает теги <script> в HTML, он загружает и выполняет JavaScript-код. Скрипты могут изменять DOM и CSSOM, добавляя интерактивность и динамические элементы на страницу.

7️⃣ Вывод на экран (рендеринг):

Браузер рассчитывает положение и размеры каждого элемента (layout) на основе дерева рендеринга. Затем он отрисовывает (paint) элементы на экране, используя графические ресурсы.

8️⃣ Рефлоу и репейнт:

Если JavaScript изменяет структуру DOM или стили CSS, браузер может повторно вычислить расположение элементов (reflow) и обновить их отрисовку (repaint). Эти процессы могут быть ресурсоемкими, поэтому важно оптимизировать код для их минимизации.

🤔 Пример:
<!DOCTYPE html>
<html lang="ru">
<head>
<meta charset="UTF-8">
<title>Пример страницы</title>
<link rel="stylesheet" href="styles.css">
</head>
<body>
<h1>Заголовок</h1>
<p>Параграф текста.</p>
<script src="script.js"></script>
</body>
</html>


🤔 В этом примере:

HTML создаёт базовую структуру страницы.

CSS-файл задаёт стили для элементов.

JavaScript добавляет интерактивность.

🤔 Вкратце: Браузер получает исходный код, анализирует HTML и CSS для создания внутренней структуры данных (DOM и CSSOM), затем выполняет JavaScript, рассчитывает расположение элементов и отображает их на экране.

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых
Please open Telegram to view this post
VIEW IN TELEGRAM
👍22🤯21
🤔 Какой атрибут тега <meta> задаёт описание страницы, которое обычно отображается в результатах поиска?
Anonymous Quiz
35%
name="description"
10%
name="keywords"
39%
content="description"
16%
type="description"
👍6