Frontend | Вопросы собесов
19.3K subscribers
33 photos
1 video
914 links
Сайт easyoffer.ru
Реклама @easyoffer_adv
ВП @easyoffer_vp

Тесты t.me/+T0COHtFzCJkwMDUy
Задачи t.me/+_tcX2w2EmvdmMTgy
Вакансии t.me/+CgCAzIyGHHg0Nzky
Download Telegram
Назови компоненты жизненного цикл ?
Спросят с вероятностью 7%

Жизненный цикл
компонента состоит из нескольких этапов, которые можно разделить на три основные фазы: монтирование, обновление и размонтирование. Каждый из этих этапов включает в себя определённые методы цикла.

1️⃣Монтирование (Mounting):
constructor(): Вызывается перед монтированием компонента. Обычно используется для инициализации состояния и привязки методов.
staticgetDerivedStateFromProps(props, state): Вызывается перед рендером компонента как при монтировании, так и при обновлении. Используется для синхронизации состояния с пропсами.
render(): Обязательный метод, который возвращает JSX-разметку компонента.
componentDidMount(): Вызывается сразу после монтирования компонента. Здесь можно выполнять запросы к API или подписываться на события.

2️⃣Обновление (Updating):
staticgetDerivedStateFromProps(props, state): Как и при монтировании, вызывается перед рендером компонента для синхронизации состояния с пропсами.
shouldComponentUpdate(nextProps, nextState): Определяет, нужно ли компоненту перерисовываться. Можно использовать для оптимизации производительности.
render(): Ререндер компонента на основе новых пропсов или состояния.
getSnapshotBeforeUpdate(prevProps, prevState): Вызывается прямо перед тем, как изменённый DOM будет отображен. Полезно для сохранения информации о DOM, которая может измениться после обновления.
componentDidUpdate(prevProps, prevState, snapshot): Вызывается сразу после обновления компонента. Можно использовать для выполнения действий после обновления, таких как запросы к API на основе новых пропсов или состояния.

3️⃣Размонтирование (Unmounting):
componentWillUnmount(): Вызывается перед размонтированием и удалением компонента. Используется для очистки ресурсов, таких как таймеры, подписки или запросы.

Пример:
class MyComponent extends React.Component {
constructor(props) {
super(props);
this.state = { count: 0 };
}

static getDerivedStateFromProps(nextProps, prevState) {
// Синхронизация состояния с пропсами
if (nextProps.count !== prevState.count) {
return { count: nextProps.count };
}
return null;
}

componentDidMount() {
// Выполнение действий после монтирования
console.log('Component mounted');
}

shouldComponentUpdate(nextProps, nextState) {
// Оптимизация перерисовки
return nextState.count !== this.state.count;
}

getSnapshotBeforeUpdate(prevProps, prevState) {
// Сохранение информации о DOM
return null;
}

componentDidUpdate(prevProps, prevState, snapshot) {
// Выполнение действий после обновления
console.log('Component updated');
}

componentWillUnmount() {
// Очистка ресурсов перед удалением компонента
console.log('Component will unmount');
}

render() {
return (
<div>
<p>Count: {this.state.count}</p>
</div>
);
}
}

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

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

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


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

Основные концепции:

1️⃣Хранилище (Store):
Хранилище — это объект, который содержит всё состояние приложения. В Redux может быть только одно хранилище. Оно создается с помощью функции createStore.
      import { createStore } from 'redux';
const store = createStore(reducer);


2️⃣Действия (Actions):
Действия — это объекты, которые описывают изменения состояния. Каждое действие имеет тип (свойство type), который указывает, какое изменение должно произойти, и дополнительные данные (payload), если это необходимо.
      const incrementAction = {
type: 'INCREMENT',
payload: 1
};


3️⃣Редюсеры (Reducers):
Редюсеры — это функции, которые определяют, как состояние приложения изменяется в ответ на действия. Они принимают текущее состояние и действие, а возвращают новое состояние.
      const initialState = { count: 0 };

function counterReducer(state = initialState, action) {
switch (action.type) {
case 'INCREMENT':
return { ...state, count: state.count + action.payload };
case 'DECREMENT':
return { ...state, count: state.count - action.payload };
default:
return state;
}
}


4️⃣Диспетчеризация (Dispatch):
Для изменения состояния приложения необходимо отправить действие в хранилище с помощью метода dispatch.
store.dispatch(incrementAction);


5️⃣Подписка (Subscription):
Приложение может подписываться на изменения состояния в хранилище, чтобы обновлять интерфейс пользователя при изменении состояния.
      store.subscribe(() => {
console.log(store.getState());
});


Пример с React:

1️⃣Установка Redux и React-Redux:
npm install redux react-redux


2️⃣Создание хранилища и редюсера:
      // store.js
import { createStore } from 'redux';

const initialState = { count: 0 };

function counterReducer(state = initialState, action) {
switch (action.type) {
case 'INCREMENT':
return { ...state, count: state.count + 1 };
case 'DECREMENT':
return { ...state, count: state.count - 1 };
default:
return state;
}
}

const store = createStore(counterReducer);
export default store;


3️⃣Подключение хранилища к React приложению:
      // index.js
import React from 'react';
import ReactDOM from 'react-dom';
import { Provider } from 'react-redux';
import App from './App';
import store from './store';

ReactDOM.render(
<Provider store={store}>
<App />
</Provider>,
document.getElementById('root')
);


4️⃣Использование состояния и действий в компонентах:
      // App.js
import React from 'react';
import { useSelector, useDispatch } from 'react-redux';

function App() {
const count = useSelector(state => state.count);
const dispatch = useDispatch();

return (
<div>
<p>Count: {count}</p>
<button onClick={() => dispatch({ type: 'INCREMENT' })}>Increment</button>
<button onClick={() => dispatch({ type: 'DECREMENT' })}>Decrement</button>
</div>
);
}

export default App;


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

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

🔐 База собесов | 🔐 База тестовых
👍4211🔥6
🤔 Какая функция JavaScript асинхронна по умолчанию?
Anonymous Quiz
90%
setTimeout()
3%
map()
3%
forEach()
3%
reduce()
👍14🤔32
Зачем нужен redux ?
Спросят с вероятностью 7%

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

1️⃣Централизованное управление состоянием
Redux хранит всё состояние приложения в одном месте, называемом хранилищем (store). Это облегчает управление состоянием и делает его предсказуемым.

2️⃣Предсказуемость состояния
Благодаря строгим правилам (например, редюсеры должны быть чистыми функциями), состояние в Redux меняется предсказуемо. Это упрощает отладку и тестирование приложения.

3️⃣Удобная отладка
Существуют инструменты, такие как Redux DevTools, которые позволяют видеть, как состояние изменяется с каждым действием. Это делает отладку проще и более наглядной.

4️⃣Управление сложным состоянием
В больших приложениях состояние может быть очень сложным и распределённым по многим компонентам. Redux помогает управлять этим состоянием, избегая "пробрасывания" пропсов через многие уровни компонентов.

5️⃣Упрощение синхронных и асинхронных операций
Redux хорошо сочетается с middleware, такими как Redux Thunk или Redux Saga, для обработки асинхронных операций, например, запросов к API. Это позволяет управлять побочными эффектами централизованно.

Пример:


1️⃣Централизованное хранилище:
Все состояния приложения хранятся в одном месте, что упрощает управление ими.
      import { createStore } from 'redux';
const store = createStore(reducer);


2️⃣Предсказуемость:
Каждый редюсер — чистая функция, которая принимает текущее состояние и действие и возвращает новое состояние.
      function reducer(state = initialState, action) {
switch (action.type) {
case 'INCREMENT':
return { count: state.count + 1 };
case 'DECREMENT':
return { count: state.count - 1 };
default:
return state;
}
}


3️⃣Отладка:
Использование Redux DevTools позволяет видеть историю изменений состояния и отладку приложения.
      // Подключение Redux DevTools
const store = createStore(reducer, window.__REDUX_DEVTOOLS_EXTENSION__ && window.__REDUX_DEVTOOLS_EXTENSION__());


4️⃣Асинхронные операции:
С помощью middleware, таких как Redux Thunk, можно обрабатывать асинхронные действия.
      import thunk from 'redux-thunk';
import { applyMiddleware, createStore } from 'redux';

const store = createStore(reducer, applyMiddleware(thunk));

// Асинхронное действие
const fetchData = () => {
return async (dispatch) => {
const response = await fetch('https://api.example.com/data');
const data = await response.json();
dispatch({ type: 'DATA_LOADED', payload: data });
};
};


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

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

🔐 База собесов | 🔐 База тестовых
👍224🔥2😁1🤯1
Что происходит в момент запроса в браузере ?
Спросят с вероятностью 3%

Когда пользователь вводит URL в адресную строку браузера и нажимает Enter, происходит ряд шагов для получения и отображения запрашиваемой веб-страницы. Этот процесс включает взаимодействие различных компонентов сети и веб-технологий. Рассмотрим основные этапы, происходящие при выполнении HTTP-запроса в браузере:

1️⃣Ввод URL и начало запроса

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

2️⃣DNS-разрешение

Если ресурс не найден в кэше, браузер выполняет запрос к DNS-серверу для преобразования доменного имени (например, www.example.com) в IP-адрес сервера.

3️⃣Установление TCP-соединения

После получения IP-адреса браузер устанавливает TCP-соединение с сервером. Этот процесс включает в себя трехэтапное рукопожатие:
Браузер отправляет SYN-пакет серверу.
Сервер отвечает SYN-ACK пакетом.
Браузер отправляет ACK-пакет, подтверждая установление соединения.

4️⃣HTTPS и SSL/TLS


Если URL использует HTTPS, происходит дополнительный этап установки защищенного соединения с использованием SSL/TLS:
Браузер и сервер обмениваются сертификатами и выполняют шифрование данных.

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

Браузер отправляет HTTP-запрос на сервер. Например, для получения главной страницы сайта может быть отправлен следующий запрос:
          GET / HTTP/1.1
Host: www.example.com


6️⃣Обработка запроса на сервере

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

7️⃣Получение и обработка HTTP-ответа

Браузер получает HTTP-ответ от сервера. Ответ включает в себя статусный код, заголовки и тело (содержимое) ответа. Пример HTTP-ответа:
          HTTP/1.1 200 OK
Content-Type: text/html
Content-Length: 1234

<!DOCTYPE html>
<html>
<head>
<title>Пример страницы</title>
</head>
<body>
<h1>Добро пожаловать!</h1>
</body>
</html>


8️⃣Парсинг и рендеринг страницы

Браузер начинает парсинг HTML-документа. Этот процесс включает построение DOM (Document Object Model) — структуры дерева, представляющей элементы страницы.
В процессе парсинга HTML браузер может обнаруживать ссылки на другие ресурсы, такие как CSS, JavaScript, изображения и шрифты, и отправлять дополнительные HTTP-запросы для их загрузки.

9️⃣Выполнение JavaScript

После парсинга HTML и CSS браузер начинает выполнение встроенных и внешних JavaScript-скриптов. JavaScript может изменять DOM и CSSOM (CSS Object Model), что приводит к изменениям в отображении страницы.
JavaScript также может отправлять асинхронные запросы (AJAX) для динамической загрузки данных и обновления страницы без перезагрузки.

🔟Финальная отрисовка

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

Когда пользователь вводит URL в браузере и нажимает Enter, происходит следующее:
1️⃣Браузер проверяет кэш и выполняет DNS-запрос для получения IP-адреса.
2️⃣Устанавливается TCP-соединение и, если используется HTTPS, SSL/TLS-соединение.
3️⃣Отправляется HTTP-запрос к серверу.
4️⃣Сервер обрабатывает запрос и возвращает HTTP-ответ.
5️⃣Браузер парсит HTML, загружает и обрабатывает ресурсы (CSS, JavaScript, изображения), строит DOM и CSSOM.
6️⃣Выполняется JavaScript, что может изменять DOM и CSSOM.
7️⃣Страница рендерится и отображается пользователю.

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

🔐 База собесов | 🔐 База тестовых
👍83🔥52
Как работает реактивность в vue.Js ?
Спросят с вероятностью 7%

Реактивность — это одна из ключевых характеристик фреймворка, которая позволяет автоматически обновлять пользовательский интерфейс при изменении состояния. Вот как это работает:

Основные концепции

1️⃣Реактивные данные:
Vue использует объекты с реактивными свойствами, чтобы отслеживать изменения. Когда данные изменяются, Vue автоматически обновляет связанные с ними компоненты.

2️⃣Объект Vue:
При создании нового экземпляра Vue, он делает все данные, определенные в опции data, реактивными.
      var vm = new Vue({
data: {
message: 'Hello Vue!'
}
});


3️⃣Реактивность через геттеры и сеттеры:
Vue использует JavaScript Proxy (или Object.defineProperty в более старых версиях) для создания реактивных свойств. Каждый раз, когда свойство считывается, вызывается геттер, и когда свойство изменяется, вызывается сеттер.

Пример реактивности
var vm = new Vue({
el: '#app',
data: {
message: 'Hello Vue!'
}
});


При изменении vm.message интерфейс автоматически обновится:
vm.message = 'Hello World!';


Как это работает "под капотом"

1️⃣Инициализация:
При инициализации Vue.js обходит все свойства объекта data и преобразует их в геттеры и сеттеры с помощью Object.defineProperty. Этот процесс называется обсервацией.

2️⃣Детекторы изменений (Observers):
Каждый раз, когда создается реактивное свойство, создается объект наблюдателя (Observer), который следит за изменениями этого свойства.

3️⃣Депенденси трекинг (Dependency Tracking):
Во время рендера компонента, Vue регистрирует все зависимости (реактивные свойства), которые используются. Это означает, что Vue "запоминает", какие свойства нужно отслеживать для каждого компонента.

4️⃣Реактивное обновление:
Когда реактивное свойство изменяется, Vue уведомляет все компоненты, которые зависят от этого свойства, и они автоматически перерисовываются.

Реактивные системы в действиях
new Vue({
el: '#app',
data: {
a: 1,
b: 2
},
computed: {
sum() {
return this.a + this.b;
}
},
watch: {
a(newValue, oldValue) {
console.log(`a изменилось с ${oldValue} на ${newValue}`);
}
}
});


Вычисляемые свойства: sum автоматически пересчитывается, когда a или b изменяются.
Наблюдатели (watchers): Реагируют на изменения данных и могут выполнять побочные эффекты.

Преимущества

1️⃣Простота использования: Можно сосредоточиться на логике приложения, а не на обновлении DOM.
2️⃣Высокая производительность: Vue эффективно отслеживает изменения и обновляет только те части DOM, которые изменились.
3️⃣Поддержка сложных приложений: Реактивная система Vue легко масштабируется для больших и сложных приложений.

Реактивность позволяет автоматически обновлять интерфейс при изменении данных. Она работает с использованием геттеров и сеттеров для отслеживания изменений и обновления связанных компонентов.

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

🔐 База собесов | 🔐 База тестовых
👍185
Расскажите о жизненном цикле компонента vue ?
Спросят с вероятностью 7%

Жизненный цикл компонента Vue.js описывает последовательность этапов, через которые проходит компонент от момента его создания до удаления. Каждый этап жизненного цикла сопровождается вызовом определенных хуков (методов), которые можно использовать для выполнения необходимых операций.

Основные этапы:

1️⃣Создание (Creation):
beforeCreate(): Вызывается сразу после инициализации экземпляра, до того как будут установлены реактивные свойства. На этом этапе к экземпляру нельзя получить доступ через this.
created(): Вызывается после создания экземпляра и установки реактивных свойств. На этом этапе уже можно получить доступ к данным и методам компонента, но ещё нет привязки к DOM.
        new Vue({
data() {
return {
message: 'Hello Vue!'
};
},
beforeCreate() {
console.log('beforeCreate');
},
created() {
console.log('created');
console.log(this.message); // 'Hello Vue!'
}
});


2️⃣Монтирование (Mounting):
beforeMount(): Вызывается перед монтированием компонента в DOM. На этом этапе шаблон ещё не скомпилирован и не вставлен в DOM.
mounted(): Вызывается после монтирования компонента в DOM. Здесь уже можно выполнять действия, зависящие от DOM, например, инициализировать сторонние библиотеки, работающие с DOM.
        new Vue({
el: '#app',
data() {
return {
message: 'Hello Vue!'
};
},
beforeMount() {
console.log('beforeMount');
},
mounted() {
console.log('mounted');
console.log(this.$el); // доступ к элементу DOM
}
});


3️⃣Обновление (Updating):
beforeUpdate(): Вызывается перед обновлением DOM, когда изменяется реактивное свойство. На этом этапе можно получить текущее состояние до обновления.
updated(): Вызывается после обновления DOM. Этот хук можно использовать для выполнения действий, зависящих от нового состояния DOM.
        new Vue({
el: '#app',
data() {
return {
message: 'Hello Vue!'
};
},
beforeUpdate() {
console.log('beforeUpdate');
},
updated() {
console.log('updated');
},
methods: {
updateMessage() {
this.message = 'Hello World!';
}
}
});


4️⃣Размонтирование (Unmounting):
beforeUnmount(): Вызывается перед размонтированием компонента и его удалением из DOM. Используется для выполнения очистки, например, отмены таймеров или отписки от событий.
unmounted(): Вызывается после того, как компонент был размонтирован и удалён из DOM.
        new Vue({
el: '#app',
data() {
return {
message: 'Hello Vue!'
};
},
beforeUnmount() {
console.log('beforeUnmount');
},
unmounted() {
console.log('unmounted');
},
methods: {
destroyComponent() {
this.$destroy();
}
}
});


Жизненный цикл компонента Vue.js включает создание, монтирование, обновление и размонтирование. Каждый этап сопровождается вызовом определенных хуков (beforeCreate, created, beforeMount, mounted, beforeUpdate, updated, beforeUnmount, unmounted), которые позволяют выполнять различные действия в нужные моменты жизни компонента.

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

🔐 База собесов | 🔐 База тестовых
👍102
🤔 Какой HTML5 элемент специфически предназначен для навигации по страницам?
Anonymous Quiz
1%
<footer>
3%
<header>
5%
<section>
91%
<nav>
👍81
Как проверить, что поле является массивом ?
Спросят с вероятностью 7%

Для проверки, является ли поле массивом, можно использовать несколько методов. Самый распространенный и рекомендуемый способ — это использование метода Array.isArray(). Этот метод проверяет, является ли переданное значение массивом, и возвращает true или false.

Пример
const arr = [1, 2, 3];
const notArr = "Hello";

console.log(Array.isArray(arr)); // true
console.log(Array.isArray(notArr)); // false


Альтернативные методы

1️⃣Проверка с помощью instanceof:
Этот метод проверяет, является ли объект экземпляром конструктора Array.
      const arr = [1, 2, 3];
const notArr = "Hello";

console.log(arr instanceof Array); // true
console.log(notArr instanceof Array); // false


2️⃣Проверка с помощью конструктора Object.prototype.toString.call():
Этот метод проверяет тип объекта, возвращаемый методом
Object.prototype.toString.

const arr = [1, 2, 3];
const notArr = "Hello";

console.log(Object.prototype.toString.call(arr) === '[object Array]'); // true
console.log(Object.prototype.toString.call(notArr) === '[object Array]'); // false



Сравнение методов

Array.isArray():
Является самым современным и предпочтительным методом.
Поддерживается всеми современными браузерами.
Легко читается и понимается.

instanceof:
Работает корректно в большинстве случаев.
  - Может давать неверные результаты, если массив создан в другом контексте (например, в iframe).

- Object.prototype.toString.call():
- Универсальный метод для проверки различных типов объектов.
- Меньше подвержен проблемам с контекстом, но выглядит менее читаемым по сравнению с Array.isArray().


Для проверки, является ли поле массивом, рекомендуется использовать метод Array.isArray(), так как он простой, эффективный и работает корректно в большинстве ситуаций.

Чтобы проверить, является ли поле массивом, можно использовать метод Array.isArray(). Этот метод возвращает true, если значение является массивом, и false в противном случае.

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

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

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

1️⃣Хранение данных на клиенте
Хранятся на стороне клиента (в браузере) и используются для сохранения информации, которая может быть полезна при последующих посещениях веб-сайта.

2️⃣Ограниченный размер
Размер каждого куки ограничен (обычно до 4KB). Поэтому куки не подходят для хранения больших объемов данных.

3️⃣Срок действия (время жизни)
Каждая кука имеет время жизни, которое задается параметром Expires или Max-Age. По истечении этого времени кука автоматически удаляется браузером.

4️⃣Доступность по домену и пути
Доступны только для указанного домена и пути. Это позволяет ограничивать доступ к кукам для других страниц и поддоменов.

5️⃣Безопасность (HTTP-only и Secure)
HTTP-only: Куки, установленные с флагом HttpOnly, недоступны через JavaScript, что помогает защитить данные от XSS-атак.
Secure: Куки, установленные с флагом Secure, передаются только по защищенному HTTPS соединению.

6️⃣Передача с запросами
Автоматически отправляются серверу с каждым HTTP-запросом к соответствующему домену, что позволяет серверу узнавать пользователя и сохранять его сессию.

Примеры использования куки

1️⃣Установка куки через JavaScript:
      document.cookie = "username=John Doe; expires=Fri, 31 Dec 2024 23:59:59 GMT; path=/";


2️⃣Чтение куки через JavaScript:
      const getCookie = (name) => {
const value = `; ${document.cookie}`;
const parts = value.split(`; ${name}=`);
if (parts.length === 2) return parts.pop().split(';').shift();
}

console.log(getCookie('username')); // 'John Doe'


3️⃣Удаление куки через JavaScript:
      document.cookie = "username=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/";


Примеры на сервере

1️⃣Установка куки на сервере (Node.js с Express):
      const express = require('express');
const app = express();

app.get('/', (req, res) => {
res.cookie('username', 'John Doe', { maxAge: 900000, httpOnly: true });
res.send('Cookie has been set');
});

app.listen(3000);


2️⃣Чтение куки на сервере (Node.js с Express):
      const express = require('express');
const cookieParser = require('cookie-parser');
const app = express();

app.use(cookieParser());

app.get('/', (req, res) => {
const username = req.cookies.username;
res.send(`Username is: ${username}`);
});

app.listen(3000);


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

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

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

useContext — это один из встроенных хуков, который позволяет компонентам подписываться на контекст и получать доступ к данным контекста. Используется для передачи данных через дерево компонентов без необходимости передавать пропсы на каждом уровне. Это особенно полезно для глобальных данных, таких как текущий авторизованный пользователь, тема (светлая/темная) или настройки локализации.

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

1️⃣Создание контекста

Для создания контекста используется функция createContext. Она возвращает объект контекста, который содержит два компонента: Provider и Consumer.
      import React, { createContext, useState } from 'react';

const MyContext = createContext();


2️⃣Provider

Компонент Provider используется для предоставления значения контекста всем дочерним компонентам. Все компоненты внутри Provider могут получить доступ к значениям, переданным в value.
      const MyProvider = ({ children }) => {
const [state, setState] = useState('Hello World');

return (
<MyContext.Provider value={{ state, setState }}>
{children}
</MyContext.Provider>
);
};


3️⃣useContext

Используется для подписки на контекст в функциональных компонентах. Он принимает объект контекста, возвращаемый из createContext, и возвращает текущее значение контекста.
      import React, { useContext } from 'react';

const MyComponent = () => {
const { state, setState } = useContext(MyContext);

return (
<div>
<p>{state}</p>
<button onClick={() => setState('New Value')}>Change Value</button>
</div>
);
};


Полный пример
import React, { createContext, useState, useContext } from 'react';

// Создание контекста
const MyContext = createContext();

const MyProvider = ({ children }) => {
const [state, setState] = useState('Hello World');

return (
<MyContext.Provider value={{ state, setState }}>
{children}
</MyContext.Provider>
);
};

const MyComponent = () => {
const { state, setState } = useContext(MyContext);

return (
<div>
<p>{state}</p>
<button onClick={() => setState('New Value')}>Change Value</button>
</div>
);
};

const App = () => (
<MyProvider>
<MyComponent />
</MyProvider>
);

export default App;


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

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

🔒 База собесов | 🔒 База тестовых
Please open Telegram to view this post
VIEW IN TELEGRAM
👍292
🤔 Какой метод массива в JavaScript применяется для преобразования всех элементов массива и создания нового массива?
Anonymous Quiz
5%
filter()
9%
reduce()
80%
map()
6%
forEach()
👍11
Что такое схлопывание границ ?
Спросят с вероятностью 7%

Схлопывание границ (или схлопывание отступов, margin collapsing) — это поведение CSS, при котором вертикальные отступы (margins) соседних блоков могут быть объединены (схлопнуты) в один отступ. Это позволяет избежать удвоения вертикальных отступов между элементами и упрощает их управление.

Основные правила

1️⃣Смежные вертикальные отступы:
Когда два вертикальных отступа соседних блоков соприкасаются, они схлопываются в один. Размер схлопнутого отступа равен наибольшему из двух схлопывающихся отступов.
      <div class="block1"></div>
<div class="block2"></div>


В данном случае итоговый отступ между .block1 и .block2 будет 30px, а не 50px.

2️⃣Родитель и первый/последний дочерний элемент:
Если первый или последний дочерний элемент имеет вертикальный отступ, он схлопывается с отступом родительского элемента, если между ними нет границ, внутреннего отступа или контента.
      <div class="parent">
<div class="child"></div>
</div>


В этом случае итоговый отступ сверху для .child будет 20px, так как отступ .child схлопывается с отступом родителя.

3️⃣Пустые блоки:
Если блок не содержит контента, границ или внутреннего отступа, его вертикальные отступы также могут схлопываться.

Примеры

Схлопывание между соседними элементами

<div class="box1">Box 1</div>
<div class="box2">Box 2</div>


Итоговый отступ между .box1 и .box2 будет 30px.

Схлопывание границ родителя и первого/последнего дочернего элемента
<div class="container">
<div class="content">Content</div>
</div>


Итоговый верхний отступ для .content будет 25px, так как отступы схлопываются.

Исключения и предотвращение схлопывания


Границы или внутренние отступы:
Если между элементами добавить границу или внутренний отступ, схлопывания не произойдет.
    .parent {
padding-top: 1px;
}


Flexbox и Grid:
Элементы, расположенные с помощью Flexbox или Grid, не схлопывают свои отступы.

Блоки с overflow: hidden, position: absolute, или display: inline-block:
Такие блоки не участвуют в схлопывании отступов.

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

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

🔒 База собесов | 🔒 База тестовых
Please open Telegram to view this post
VIEW IN TELEGRAM
👍255🔥3
🤔 Какой тег HTML используется для встраивания исполняемого кода написанного на JavaScript?
Anonymous Quiz
94%
<script>
2%
<js>
4%
<code>
0%
<embed>
13😁8👍1🤯1
В чем преимущество методологии bem ?
Спросят с вероятностью 7%

Методология БЭМ (Блок, Элемент, Модификатор)
— это подход к написанию и организации CSS кода, который помогает создавать масштабируемые и поддерживаемые интерфейсы. Основные преимущества методологии:

1️⃣Четкая структура и семантика

БЭМ обеспечивает ясную и логичную структуру именования классов, что делает код более читаемым и понятным. Это особенно полезно в больших проектах.
<div class="button button--primary">
<span class="button__text">Click me</span>
</div>


2️⃣button — блок
button__text — элемент
button--primary — модификатор

2️⃣Изоляция компонентов

Блоки в БЭМ независимы и изолированы друг от друга, что предотвращает проблемы с каскадностью и неожиданным переопределением стилей.
<div class="header">
<div class="header__logo"></div>
<div class="header__nav"></div>
</div>

<div class="footer">
<div class="footer__logo"></div>
</div>


Классы .header__logo и .footer__logo не пересекаются и не влияют друг на друга.

3️⃣Легкость в переиспользовании

Блоки можно легко переиспользовать в разных частях проекта или даже в разных проектах без изменения их стилей.
<div class="card">
<div class="card__title">Title</div>
<div class="card__content">Content</div>
</div>

<div class="profile">
<div class="card">
<div class="card__title">Profile Title</div>
<div class="card__content">Profile Content</div>
</div>
</div>


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

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

5️⃣Унификация стилей

Методология БЭМ способствует унификации и стандартизации стилей, что упрощает работу с проектом и делает его более предсказуемым.

Пример
HTML:
<div class="menu">
<div class="menu__item menu__item--active">Home</div>
<div class="menu__item">About</div>
<div class="menu__item">Contact</div>
</div>


CSS:
.menu {
background-color: #fff;
border: 1px solid #ccc;
}

.menu__item {
padding: 10px;
color: #333;
}

.menu__item--active {
background-color: #007bff;
color: #fff;
}


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

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

🔒 База собесов | 🔒 База тестовых
Please open Telegram to view this post
VIEW IN TELEGRAM
18👍16😁3🤔1
Что такое всплытие ?
Спросят с вероятностью 7%

Всплытие (или бабблинг, event bubbling) — это механизм обработки событий в веб-разработке, при котором событие, происходящее на одном элементе, сначала обрабатывается этим элементом, а затем последовательно передаётся (всплывает) вверх по дереву DOM к его родительским элементам вплоть до корневого элемента (обычно document).

Как работает всплытие событий

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

Рассмотрим пример с вложенными элементами и обработчиками событий:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Event Bubbling</title>
</head>
<body>
<div id="parent" style="padding: 20px; background-color: lightblue;">
Parent
<div id="child" style="padding: 20px; background-color: lightcoral;">
Child
</div>
</div>

<script>
document.getElementById('parent').addEventListener('click', () => {
alert('Parent clicked!');
});

document.getElementById('child').addEventListener('click', () => {
alert('Child clicked!');
});
</script>
</body>
</html>


В этом примере, если вы кликнете на элемент #child, вы увидите два алерта: сначала "Child clicked!", затем "Parent clicked!". Это происходит потому, что событие клика всплывает от элемента #child к его родителю #parent.

Управление всплытием

Иногда нужно предотвратить всплытие события, чтобы оно не передавалось родительским элементам. Это можно сделать с помощью метода event.stopPropagation().
<script>
document.getElementById('parent').addEventListener('click', () => {
alert('Parent clicked!');
});

document.getElementById('child').addEventListener('click', (event) => {
alert('Child clicked!');
event.stopPropagation(); // предотвращает всплытие события
});
</script>


Теперь, если вы кликнете на элемент #child, вы увидите только алерт "Child clicked!", так как всплытие события было остановлено.

Захват событий

Помимо всплытия, существует другой этап обработки событий, называемый захватом (event capturing). Событие сначала идет сверху вниз от корневого элемента к цели (начиная с document и заканчивая целевым элементом), а затем поднимается обратно вверх (всплытие).

Чтобы добавить обработчик на этапе захвата, нужно передать true в качестве третьего аргумента в addEventListener:
<script>
document.getElementById('parent').addEventListener('click', () => {
alert('Parent clicked!');
}, true);

document.getElementById('child').addEventListener('click', () => {
alert('Child clicked!');
}, true);
</script>


Всплытие событий — это механизм, при котором событие сначала обрабатывается целевым элементом, а затем передается его родителям по дереву DOM. Чтобы остановить всплытие, можно использовать event.stopPropagation().

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

🔒 База собесов | 🔒 База тестовых
Please open Telegram to view this post
VIEW IN TELEGRAM
👍264👀1
Forwarded from easyoffer
Канал приближается к 20к подписчиков, а здесь так и нет нормального контент плана 😒

Ищу талантливых журналистов, способных писать клевые и авторские посты на тему "Карьера в IT" и все что с этим связано: поиск работы, повышение з/п, разбор кейсов, переезд в другие страны по рабочим визам, аналитика, исследование рынка и т.д.

Важно глубокое понимание IT индустрии, вы должны иметь опыт работы в ней

Если интересно отправьте мне свое резюме @kivaiko
🤔2👀2
🤔 Какой HTML5 API предназначен для хранения данных в браузере, даже после закрытия вкладки?
Anonymous Quiz
6%
sessionStorage
77%
localStorage
15%
cookies
2%
databaseStorage
9👍2😁1
Что такое ssr ?
Спросят с вероятностью 7%

SSR (Server-Side Rendering) — это технология рендеринга веб-страниц на сервере, а не на клиенте. В контексте современных JavaScript-фреймворков, таких как React или Vue.js, это означает, что HTML-код страницы генерируется на сервере и отправляется в браузер уже готовым для отображения. Это отличается от традиционного подхода клиентского рендеринга (Client-Side Rendering, CSR), где HTML генерируется непосредственно в браузере с использованием JavaScript.

Основные особенности и преимущества

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

2️⃣Лучшая поддержка SEO:
Статические HTML-страницы, генерируемые сервером, легче индексируются поисковыми системами, что улучшает видимость сайта в поисковых результатах.

3️⃣Улучшенное восприятие пользователем (First Paint):
Пользователи видят контент быстрее, так как сервер отправляет уже готовую HTML-разметку.

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

1️⃣Запрос от клиента:
Браузер отправляет запрос на сервер для получения страницы.

2️⃣Генерация HTML на сервере:
Сервер запускает JavaScript-код для рендеринга компонента или всей страницы.
Сервер генерирует HTML-код и отправляет его клиенту.

3️⃣Отображение страницы в браузере:
Браузер получает готовую HTML-страницу и отображает её.
Затем JavaScript-фреймворк (например, React или Vue) «гидрирует» страницу, то есть связывает готовую HTML-разметку с JavaScript-кодом, чтобы сделать страницу интерактивной.

Next.js — популярный фреймворк для React, который поддерживает SSR из коробки.

1️⃣Установка Next.js:
      npx create-next-app my-ssr-app
cd my-ssr-app
npm run dev


2️⃣Создание страницы с SSR:
      // pages/index.js
import React from 'react';

const Home = ({ data }) => {
return (
<div>
<h1>Server-Side Rendering Example</h1>
<p>{data.message}</p>
</div>
);
};

// Эта функция вызывается на сервере при каждом запросе к странице
export async function getServerSideProps() {
// Выполняем запрос к API или базе данных
const res = await fetch('https://api.example.com/data');
const data = await res.json();

// Передаем данные как пропсы в компонент
return {
props: {
data
}
};
}

export default Home;


В этом примере Next.js использует функцию getServerSideProps для получения данных на сервере перед рендерингом страницы. Эти данные затем передаются в компонент как пропсы и используются для генерации HTML.

SSR (Server-Side Rendering) — это процесс рендеринга веб-страниц на сервере, а не в браузере. Это улучшает производительность, SEO и восприятие пользователем за счет отправки готового HTML-кода с сервера.

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

🔒 База собесов | 🔒 База тестовых
Please open Telegram to view this post
VIEW IN TELEGRAM
👍34🔥52😁1
🤔 Какой атрибут для `<input>` определяет, что поле должно быть заполнено перед отправкой формы?
Anonymous Quiz
87%
required
1%
mandatory
2%
needed
10%
validate
👍14😁2🤯2