РЕАКТ — это разработчики библиотеки JavaScript с открытым исходным кодом, используемые для создания интерактивных пользовательских интерфейсов и компонентов пользовательского интерфейса для веб-сайтов и мобильных устройств. Создано Иордан Уолке, инженером программного обеспечения Facebook, первая версия реагирования вышла семь лет назад. Теперь Facebook поддерживает его. С момента своего первоначального выпуска популярность реагирования стремилась.
В октябре 2020 года React 17 было объявлено — удивительно — ноль новых функций. Тем не менее, это, безусловно, ничего не значит, что захватывающее было добавлено. Фактически, этот выпуск поставляется со многими перспективными обновлениями, включая несколько улучшений и исправлений ошибок до экспериментальных особенностей версии 16: одновременный режим и ожидание.
Хотя это еще не доступно для широкой общественности, эти функции доступны для экспериментов для разработчиков. Если и когда вы освобождены, они установлены для изменения способа React Reacts, использует свой интерфейс, улучшая как производительность, так и пользовательский опыт.
Очень кратко, функции одновременного режима и неизвестности позволяют пользователям обрабатывать загрузку данных, состояний загрузки и пользовательский интерфейс более скудливо и без проблем. В одновременном режиме реагирование может приостановить дорогие, не срочные компоненты от рендеринга и сосредоточиться на более непосредственном или срочном поведении, такими как рендеринг пользовательского интерфейса и сохранение адаптации приложения.
Эта статья принимает всеобъемлющий вид одновременного режима и неизвестности для получения данных.
Почему одновременный режим?
JavaScript Frameworks или библиотеки работают с одним потоком. Итак, когда блок запуска кода, остальные блоки должны ждать выполнения. Они не могут сделать какую-либо работу одновременно. Эта концепция применяется к рендеринге.
После того, как реагирование начнет что-то оказывать, вы не можете прерывать его. Разработчики реагирования относятся к этому рендерингу как «блокирующее рендеринг». Эта блокирующая рендеринг создает пользовательский интерфейс, который является jerky и перестает от времени перестать реагировать. Давайте посмотрим на проблему.
Эта проблема
Представьте, что у нас есть приложение, которое отображает длинный список фильтрующих продуктов. У нас есть поле поиска, где мы можем фильтровать записи. Мы хотим повторно отображать UI и список каждый раз, когда пользователь нажимает ключ.
Если список длинный, пользовательский интерфейс «Запишивает», то есть рендеринг виден пользователю. Заикание также ухудшает производительность. Разработчики могут использовать несколько техник, таких как дросселирование и деборудование, которые мало помогают, но не являются решением.
Дроссеты ограничивают количество раз, когда вызывается конкретная функция. Использование дросселирования мы можем избежать повторных вызовов на дорогие и трудоемкие API или функции. Этот процесс резко увеличивает производительность, особенно для отображения информации на пользовательском интерфейсе.
Отчитывание игнорирует вызова к функции для заранее определенного количества времени. Вызов функции выполнен только после того, как предварительно определенное количество времени прошло.
Вы можете увидеть заикание на изображении ниже.
В ожидании неотрезанных вызовов API для завершения, заиплинам UI, которые блокируют рендуринг пользовательского интерфейса. Решение прерывает рендурирование с использованием одновременного режима.
Прерываемый рендеринг
С прерываемым рендерингом rance.js не блокирует пользовательский интерфейс, в то время как IT-обрабатывает и повторно отображает список. Это делает React.js больше гранулирования путем приостановки тривиальной работы, обновляя DOM и гарантируя, что UI не заикается.
Обновления реагирования или перекраски в поле ввода с помощью пользовательского ввода параллельно. Это также обновляет список в памяти. После реагирования заканчивает обновления, он обновляет DOM и повторно отображает список на дисплее пользователя. По сути, прерываемый рендеринг позволяет реагировать на «многозадачность». » Эта функция предоставляет более опыт использования жидкости.
Одновременный режим
Одновременный режим — это набор функций, которые помогают реагировать приложения, оставайтесь отзывчивыми и плавно регулируются на устройство пользователя и возможности сети сети.
Одновременный режим делит задачи, которые он имеет в даже меньшие куски. Планировщик Rection может выбрать и выбрать, какие задания делать. Планирование рабочих мест зависит от их приоритета. При приоритетах задачи он может остановить тривиально или неотрезать или подтолкнуть их дальше. Реагирование всегда дает главный приоритет для обновления и рендеринга пользовательского интерфейса.
Используя параллельный режим, мы можем:
- Управляйте первым процессом рендеринга
- Расставлять приоритеты процессов рендеринга
- Приостановить и возобновить рендеринг компонентов
- Кэш и оптимизировать рендеринг времени выполнения компонентов
- Скрыть содержимое с дисплея до требуется
Наряду с рендерингом UI одновременный режим улучшает ответы на входящие данные, ленивые компоненты и асинхронные процессы. Одновременный режим сохраняет пользовательский интерфейс в реактивном и обновлении, пока он обновляет данные на заднем плане. Одновременный режим работает с двумя реактивными крючками: Zetransition и UseeferredValue.
Использование крюка отложенного значения
Синтаксис крючкового крючка используется,
const deferredValue = useDeferredValue(value, { timeoutMs: });
Эта команда приводит к тому, что значение «отставать» для временного набора в таймсуитах. Команда сохраняет пользовательский интерфейс в реактивном и отзывчивом, должен ли пользовательский интерфейс должен быть немедленно обновлен или должен ждать данных. Этот крюк позволяет избежать заикания пользовательского интерфейса и сохраняет пользовательский интерфейс в любое время на незначительную стоимость удержания отставок данных.
Использование переходного крюка
Крюк Usetransition — это реактивный крюк, используемый в основном с ожиданием. Рассмотрим следующий сценарий, где есть веб-страница с кнопками с именами пользователя на них. С помощью кнопки кнопка веб-страница отображается подробности пользователя на экране.
Допустим, пользователь снаe сначала нажал на одну кнопку, а затем следующий. Экран либо проходит пустым, либо получаем спиннер на экране. Если детали получения требуются слишком длинные, пользовательский интерфейс может заморозить.
Метод Usetransition возвращает значения двух крючков: StartTransition и Respending. Синтаксис для метода Usetransition:
const [startTransition, isPending] = useTransition({ timeoutMs: 3000 });
Синтаксис StartTransition:
{isPending? " Loading...": null}
Использование крюка Usetransition RACT.JS продолжает показывать пользовательский интерфейс без деталей пользователя, пока подробности пользователя не будут готовы, но UI отзывчивается. Реагируйте приоритеты пользовательского интерфейса, чтобы она отзывчивала его, при этом привлечение данных параллельно.
Взверенность для получения данных
Suspense — это еще одна экспериментальная функция, которая реагирует наряду с одновременным режимом. SOUSSENT позволяет компонентам ждать заранее определенный период до того, как они представляют.
Основной целью неизвестности является чтение данных из компонентов асинхронно, не беспокоя о источнике данных. Взять лучше всего работает с концепцией ленивой нагрузки.
Suspense Позволяет библиотеки для получения данных для информирования реагирования того, готовы ли компоненты данных для использования. С помощью этой связи RECT не будет обновлять пользовательский интерфейс, пока не будут готовы необходимые компоненты.
Включение ожидания:
- Интеграция между библиотеками получения данных и компонентами реагирования
- Управление визуальными загрузками
- Избегать гоночных условий
Основной синтаксис Спиннер компонент составляет:
import Spinner from './Spinner';}>
ВОЗМОЖНОСТЬ, используемая в одновременном режиме, позволяет детальным компонентам начать рендеринг при ожидании ожидания данных. Это показывает заполнители в то же время. Эта комбинация производит более жидкий опыт пользовательского интерфейса.
Возразма и ленивые компоненты
React.lazy — это новая функция, которая позволяет реактировать .js нагружать компоненты лениво. Ленивая загрузка означает, что компоненты загружаются (их код извлекается и отображается) только при необходимости. Они определяют приоритеты наиболее важнейших компонентов пользовательского интерфейса. Разработчики реагирования рекомендуют упаковать ленивые компоненты внутри компонента ожидания.
Это гарантирует, что когда компонент рендеринга, нет «плохих состояний». » Пользовательский интерфейс остается отзывчивым на протяжении всего процесса и приводит к более активному пользователю жидкости.
Включение одновременного режима
Чтобы включить параллельный режим, установите экспериментальную READ-версию. Предварительное условие для установки RECT — это менеджер пакета узла (NPM). Чтобы установить экспериментальную версию, выпустите команду в командной строке.
npm install react@experimental react-dom@experimental
Чтобы проверить, настроено ли экспериментальная сборка, создайте образец приложения RACT. Без экспериментальных функций код рендеринга выглядит следующим образом:
import * as React from 'react';
import { render } from 'react-dom';
render(В одновременном режиме написать этот код:
import * as React from 'react';
import { createRoot } from 'react-dom';
createRoot(document.getElementById('root')).render(Это позволяет одновременному режиму для всего приложения.
Реагирование разбивает рендеринг вызова на две части:
- Создайте корневой элемент
- Используйте вызов рендеринга
В настоящее время React планирует поддерживать три режима:
- Устаревший режим является традиционный или текущий режим для обратной совместимости
- Режим блокировки является промежуточной стадией в одновременном развитии режима
- Одновременный режим
Режим блокировки использует вызов CreateBlockingRoot вместо вызова CreateRoot. Режим блокировки дает разработчикам возможность исправить ошибки и решать проблемы во время одновременного режима разработки.
Реагистрационная документация утверждает, что каждый режим поддерживает следующие функции:
Пример приложения
Мы создали приложение для пикселей, чтобы продемонстрировать разницу между одновременным режимом и другими режимами, которые используют традиционный или блочный рендеринг. Приложение Pixels составляет 150 на 150 холсте со словами случайных пикселей и поле поиска. Каждый раз, когда пользователь в поле поиска в поле поиска, Canvas повторно редит сам.
Несмотря на то, что интернет-интерфейс не представляет в одном режиме, пользовательский ввод не включает обновления. Пиксель холст повторной рендеры после завершения обработки. В устаревших режимах, при наборе быстрого ввода, пользовательские интерфейсы останавливаются, а иногда и ворсит, прежде чем он может снова сделать холст. Пользовательский ввод также забивает и не обновляет.
Основной файл для создания приложения Pixels является Canvas.js. Мы также сделали входную коробку, где пользователь может ввести что-нибудь. Каждый пресс ключа повторно редит холст пикселей.
Кодовые файлы
Index.js.
import React from "react";
import ReactDOM from "react-dom";
import App from "./App";
// Traditional or non-Concurrent Mode react
const rootTraditional = document.getElementById("root");
ReactDOM.render(App.js.
import React, { useState, useDeferredValue } from "react";
import "./App.css";
import { Canvas } from "./Canvas";
export default function App(props)
{ const [value, setValue] = useState("");
//This is available only in the Concurrent mode.
const deferredValue = useDeferredValue(value, {
timeoutMs: 5000
});
const keyPressHandler = e => {
setValue(e.target.value);
};
return (
{props.caption}
);
}
Canvas.js.
import React from "react";
const CANVAS_SIZE = 70;
const generateRandomColor = () => {
var letters = "0123456789ABCDEF";
var color = "#";
for (var i = 0; i < 6; i++) {
color += letters[Math.floor(Math.random() * 16)];
}
return color;
};
const createCanvas = (rows, columns) => {
let array = [];
for (let i = 0; i < rows; i++) {
let row = [];
for (let j = 0; j < columns; j++) {
row.push(0);
}
array.push(row);
}
return array;
};
//This is the square with the pixels
const drawCanvas = value => {
const canvas = createCanvas(CANVAS_SIZE, CANVAS_SIZE);
return canvas.map((row, rowIndex) => {
let cellsArrJSX = row.map((cell, cellIndex) => {
let key = rowIndex + "-" + cellIndex;
return (
);
});
return (
{cellsArrJSX}
);
});
};
export const Canvas = ({ value }) => {
return (
{value}
{drawCanvas(value)}
);
};
Index.html.
React App Concurrent Mode
Запуск кода
Давайте посмотрим на наш код в действии. Первый экран, который мы видим, это начальный экран. Использование традиционного или блочного рендеринга заключается в том, как реагируют это сегодня. Прерываемый рендеринг представляет собой экспериментальную особенность одновременного рендеринга. Сначала мы смотрим на традиционные рендеринг.
Пиксель холст повторно рендерирует на каждом клавиш. В традиционном рендеринге все Ui останавливает для каждого нажатия клавиши, пока он не сможет повторно отобразить экран. В течение этого времени пользовательский ввод также не принимается, даже если мы продолжаем печатать.
Следующий экран показывает прерываемый рендеринг. В прерыванном рендеринге пользователь может продолжать печатать. Уэй не пробивает или остановился, пока холст повторно отображается для каждого нажатия клавиши параллельно.
После завершения повторного рендеринга реагируйте обновления UI. Хотя трудно увидеть в неподвижном экране, мы видим, что сетка меняется, но пользователь все еще может ввести без заикания UI.
Резюме
В этой статье мы смотрели на экспериментальные функции React, одновременный режим и неизвестность. Используя параллельный режим, Rect.js постоянно отзывчивает пользовательский интерфейс.
Он нарушает задачи приложения на меньшие куски и позволяет определять приоритету задач пользовательского интерфейса. Следовательно, этот режим предоставляет более жидкий и бесшовный пользовательский опыт и увеличивает общую производительность приложения.
В сочетании с одновременным режимом ожидания позволяет пользователю интерфейс оставаться отзывчивым. В то же время, тяжелые и трудоемкие задачи, такие как данные для получения данных, и так далее, могут быть выполнены параллельно, что обеспечивает общий опыт работы.
Полная информация о параллельном режиме доступна в Реагистрационная документация Отказ
Оригинал: «https://dev.to/grapecity/experimental-react-concurrent-mode-is-coming-34d5»