Вот несколько причин, почему реагировать так быстро стал настолько популярным:
- Работа с API DOM сложно. Реагически в основном дает разработчикам возможность работать с виртуальным браузером, который более дружелюбный, чем реальный браузер. Виртуальный браузер Rection действует как агент между разработчиком и реальным браузером.
- React позволяет разработчикам деклариво описать их пользовательские интерфейсы и моделировать состояние этих интерфейсов. Это означает, что вместо того, чтобы прийти с шагами для описания транзакций на интерфейсах, разработчики просто описывают интерфейсы с точки зрения конечного состояния (например, функции). Когда транзакции случаются с этим состоянием, RECT позаботится о обновлении пользовательских интерфейсов на основе этого.
- React – это просто JavaScript, есть очень маленький API для изучения, всего несколько функций и как их использовать. После этого ваши навыки JavaScript – это то, что делает вас лучшим разработчиком реагирования. Там нет препятствий для въезда. Разработчик JavaScript может стать продуктивным разработчиком реагирования в течение нескольких часов.
Но есть намного больше, чем просто это. Давайте попытаемся охватить все причины, основанные на повышении популярности реагирования. Одна из причин является его виртуальный DOM (алгоритм примирения реагирования). Мы будем работать через пример, чтобы показать фактическую практическую ценность наличия такого алгоритма в вашей команде.
Официальное определение реагирования утверждает, что это JavaScript Библиотека для строительства пользовательских интерфейсов Отказ Важно понимать две разные части этого определения:
- Реагировать – это JavaScript Библиотека Отказ Это не каркас. Это не полное решение, и нам часто нужно использовать больше библиотек с реагированием на любой раствор. Реагирование не принимает ничего о других частях в любом полном решении. Он ориентирован на одну вещь, и делать это очень хорошо.
- То, что реагирует действительно хорошо, является второй частью определения: Строительные пользовательские интерфейсы Отказ Пользовательский интерфейс – это все, что мы помещаем перед пользователями, чтобы они взаимодействуют с машиной. Пользовательские интерфейсы повсюду, от простых кнопок на микроволновой пачке к приборной панели космического челнока. Если устройство, которое мы пытаемся интерфейс, могут понять JavaScript, мы можем использовать реагирование, чтобы описать для него пользовательский интерфейс.
Поскольку веб-браузеры понимают JavaScript, мы можем использовать Reaction, чтобы описать интерфейсы веб-пользователей. Мне нравится использовать слово Опишите Вот потому что это то, что Мы В основном делайте с реагированием, мы просто говорим, что мы хотим, и реагируют, построят фактические пользовательские интерфейсы, в нашем имени в веб-браузере. Без реагирования или аналогичных библиотек нам необходимо вручную построить пользовательские интерфейсы с собственными веб-API и JavaScript.
Когда вы слышите утверждение, что «React является декларативным», это именно то, что значит, мы описываем пользовательские интерфейсы с реагированием и сообщите им, что мы хотим (не как это сделать). Реагирование позаботится о «Как» и переводить наши декларативные описания (которые мы пишем на языке RACT) на фактические пользовательские интерфейсы в браузере. React разделяет эту простую декларативную мощность с самим HTML, но с реагированием мы получаем декларативные для интерфейсов HTML, которые представляют динамические данные, а не только статические данные.
React имеет три основных концепция дизайна, которые управляют своей популярностью:
1 – использование многоразовых, компонентов, компонентов и указов
В реакции мы описываем пользовательские интерфейсы с использованием компонентов. Вы можете подумать о компонентах как простых функциях (на любом языке программирования). Мы называем функции с некоторыми вводами, и они дают нам некоторые вывод. Мы можем повторно использовать функции по мере необходимости и создавать более крупные функции из более мелких.
Компоненты точно такие же; Мы называем их входные «свойства» и «состояние», а выход компонента – это описание пользовательского интерфейса (который аналогичен HTML для браузеров). Мы можем повторно использовать один компонент в нескольких пользовательских интерфейсах, а компоненты могут содержать другие компоненты.
Однако в отличие от чистых функций, полный реактивный компонент может иметь частное состояние для хранения данных, которые могут меняться со временем.
2 – характер реактивных обновлений
Имя Rection – это простое объяснение этой концепции. Когда состояние компонента (входной) изменяется, пользовательский интерфейс он представляет собой (выходные) изменения. Это изменение в описании пользовательского интерфейса должно быть отражено на устройстве, с которым мы работаем.
В браузере нам нужно восстановить представления HTML в модели объекта документа (DOM). С реагированием нам не нужно беспокоиться о Как Чтобы отразить эти изменения или даже управлять Когда принять изменения в браузер; Реагировать просто реагировать в состояние изменения и автоматически обновлять DOM при необходимости.
3 – Виртуальное представление взглядов в памяти
С реагированием мы пишем HTML с помощью JavaScript. Мы полагаемся на мощность JavaScript для генерации HTML, который зависит от некоторых данных, а не повышения HTML, чтобы сделать его работать с этими данными. Усиление HTML – это то, что обычно делают другие структуры JavaScript. Например, угловые расширяют HTML с функциями, такими как петли, условные условные и другие.
Когда мы получаем только данные с сервера (на заднем плане, с ajax), нам нужно что-то большее, чем HTML для работы с этими данными. Он либо использует расширенный HTML или использование мощности самого JavaScript для генерации HTML. Оба подхода имеют преимущества и недостатки. Реагировать охватывает последний, с аргументом, что преимущества сильнее, чем недостатки.
На самом деле, существует одно основное преимущество, которое может иметь дело для этого подхода самостоятельно; Использование JavaScript для рендеринга HTML позволяет легко реагировать на хранение виртуального представления HTML в памяти (который обычно известен как виртуальный DOM ). Реагирование использует виртуальный DOM для визуализации HTML-дерева практически сначала, а затем каждый раз, когда государственные изменения, и мы получаем новое дерево HTML, которое необходимо предпринять в доме браузера, вместо того, чтобы написать все новое дерево только Разница между новым деревом и предыдущим деревом (поскольку реакция имеет как деревья в памяти). Этот процесс известен как Вымирание дерева И я думаю, что это лучшее, что произошло в веб-разработке, так как Ajax!
В следующем примере мы сосредоточимся на этой последней концепции и видим простой практический пример процесса примирения дерева и большая разница, которое она делает. Мы напишем один и тот же HTML-пример дважды, сначала используя родные веб-API и ванильный JavaScript, а затем посмотрим, как описать то же дерево HTML с реагированным.
Чтобы чисто сосредоточиться на этой последней концепции, мы не будем использовать компоненты, и мы будем уделять операцию изменения состояния с помощью таймера JavaScript. Мы также не собираемся использовать JSX, хотя использование JSX сделает намного более простой код. Я использую JSX все время, когда я пишу реагирование, но работа с API RACT, непосредственно в этом примере, надеюсь, заставит вас понять эту концепцию намного лучше.
Пример алгоритма примирения РФ
Чтобы следить с этим примером, вам нужен браузер и редактор кода. Вы можете использовать онлайн-компонентную игровую площадку, но я буду использовать локальные файлы и тестировать их непосредственно в браузере (нам не нужен веб-сервер):
Мы начнем этот пример с нуля. Создайте новый каталог и запустите свой любимый редактор там:
mkdir react-democd react-demoatom .
Создать index.html Файл в этом каталоге и поместите стандартный шаблон HTML там. Включить в этот шаблон A Script.js Файл и поставить console.log Заявление в этом скрипте для проверки того, что включают работы:
React Demo
Открыть index.html Файл в вашем браузере и убедитесь, что вы можете увидеть пустой шаблон без проблем, и что вы можете увидеть в вкладке Console DEV-Tools console.log Тестовое сообщение, которое вы помещаете в Script.js :
open index.html # On Mac explorer index.html # On Windows
Теперь давайте принесем саму по себе библиотеку RACT, которую мы можем включить из Enternjs сайт Отказ Скопируйте оба реагировать и React-Dom скрипты и включите их в index.html :
Мы включаем два разных сценария здесь для важной причины: Реагировать Сама библиотека может быть использована без браузера. Чтобы использовать React с браузером, нам нужны Реагировать библиотека.
Когда мы обновляем браузер сейчас, мы должны увидеть оба Реагировать и Реагировать Доступно на глобальном масштабе:
С этой простой настройкой мы можем получить доступ к обоим Реагировать и Реагировать API, и, конечно, у нас также есть доступ к родным веб-API и JavaScript, который мы собираемся использовать в первую очередь.
Чтобы динамически вставлять HTML в браузере, мы можем просто использовать чистый JavaScript и сам сам Дом Web API. Давайте создадим Div Элемент для размещения нашего HTML-контента JavaScript и дать ему идентификатор «JS» Отказ В элементе тела index.html прямо до Сценарий Tag, Добавить:
Сейчас в Script.js Давайте схватим этот новый Div элемент по его идентификатору и положить его в константу. Давайте назвать эту константу jscontainer Отказ Мы можем использовать Документ. GteletelementbyId захватить Div Из HTML:
jsContainer.innerHTML = `Hello JS`;
Контролировать содержание этого Div мы можем использовать innerhtml Установка вызова на Div элемент напрямую. Мы можем использовать этот вызов, чтобы поставить любой HTML-шаблон, который мы хотим вставлены в DOM. Давайте вставить Div Элемент с классом «демонстрационного» и струны «Hello JS» в качестве содержания:
jsContainer.innerHTML = `Hello JS`;ReactDOM.render( /* TODO: React's version of the HTML template */, reactContainer )
Убедитесь, что это работает в браузере. Вы должны увидеть линию «Hello JS» на экране.
Это DEMO Div – наш пользовательский интерфейс до сих пор. Это очень простой. Мы просто выводим текст для пользователя, чтобы увидеть.
Оба Документ. GteletelementbyId и element.innerhtml на самом деле являются частью собственного DOM Web API. Мы связываемся с браузером непосредственно здесь, используя поддерживаемые API веб-платформы. Однако, когда мы пишем React Code, мы используем вместо этого API API API, и мы позволяем взаимодействовать с браузером, используя браузер с помощью DOM Web API.
Рейкт действует как наш агент Для браузера, и мы в основном Нужно общаться с просто реагировать, нашим агентом, а не сам браузер. Я говорю в основном, потому что есть случаи, когда нам все еще нужно общаться с браузером, но это редки.
Чтобы создать точно такой же пользовательский интерфейс, который мы имеем до сих пор, но с API age API давайте создадим другой Div элемент и дать ему удостоверение личности «Реагировать» Отказ В index.html , прямо под Div # JS Элемент, Добавить:
Сейчас, в Script.js Создайте новую контейнерную константу для нового Div :
const reactContainer = document.getElementById("react");Этот контейнер будет единственным вызовом, который мы делаем на родной веб-API. Реантрегистрация нуждается в этом контейнере, чтобы знать, где провести наше приложение в доме.
С идентифицированным React Container мы можем теперь использовать библиотеку реагирования на оказывать Реакция версия шаблона HTML к этому контейнеру:
ReactDOM.render( /* TODO: React's version of the HTML template */, reactContainer )
То, что мы собираемся сделать дальше, это ваша первая веха в действительно понимании библиотеки Ractive. Помните, когда я сказал вам, что с реагированием мы пишем HTML с помощью JavaScript? Это именно то, что мы собираемся делать дальше.
Чтобы написать наш простой пользовательский интерфейс HTML, мы собираемся использовать вызовы JavaScript для API ageC, и к концу примера у вас будет лучшая картина по причине для этого.
Вместо того, чтобы работать с строками (как мы сделали в собственном примере JavaScript выше), в реакции мы работаем с Объекты Отказ Любая HTML-строка будет представлена как объект, использующий A Rect.Createelement Вызов (который является основной функцией в API RACT).
Вот эквивалентный пользовательский интерфейс HTML, который мы имеем до сих пор с реагированием:
ReactDOM.render(
React.createElement(
"div",
{ className: "demo" },
"Hello React"
),
reactContainer
);Rect.Createelement Имеет много аргументов:
- Первый аргумент – это тег HTML, который является
DivВ нашем примере. - Второй аргумент – это объект, который представляет любые атрибуты, которые мы хотим иметь этот тег. Чтобы соответствовать родным примере JS, который мы использовали
{ClassName: «Демо»}который переводится наClass = "Demo"Отказ Обратите внимание, как мы использоваликлассное значениевместоКлассВ атрибутах, поскольку с реагированием это все JavaScript, который соответствует веб-API, а не HTML. - Третий аргумент – это содержание элемента. Мы поставили «Hello Rect» string там.
Мы можем проверить это сейчас. Браузер должен сделать оба «Hello JS», так и «Реагирование Hello». Давайте стиль демонстрацию Divs в качестве коробки, используя эту CSS, просто так, чтобы мы могли визуально разделить экран. В index.html :
Теперь у нас есть два узла, которые контролируются с помощью DOM Web API напрямую, и другой управляемый с помощью API RACT (что, в свою очередь, использует DOM Web API). Единственная важная разница между тем, как мы строим эти два узла в браузере, заключается в том, что в версии JS мы использовали строку для представления содержимого, в то время как в версии RACT READ мы использовали чистые вызовы JavaScript и представляли контент с объектом вместо строка.
Независимо от того, насколько сложный пользовательский интерфейс HTML будет получать, при использовании React, каждый HTML-элемент будет представлен с помощью объекта JavaScript с использованием A Rect.Createelement вызов.
Давайте теперь добавим еще несколько функций на наш простой пользовательский интерфейс. Давайте добавим текстовое поле, чтобы прочитать вход от пользователя.
Чтобы гнездиться элементами в нашем шаблоне HTML, он прямой вперед в версии JS, потому что это просто HTML. Например, чтобы сделать демонстрацию Div оказывать <ввод/> Элемент, мы просто добавляем его к контенту:
jsContainer.innerHTML = `Hello JS`;
Мы можем сделать то же самое с реагированием, добавив больше аргументов после 3-го аргумента для Rect.Createelement Отказ Чтобы соответствовать тому, что мы сделали в собственном примере JS, мы можем добавить 4-й аргумент, который является еще одним Rect.Createelement Позвоните, что делает вход Элемент (помните, каждый HTML-элемент является объектом):
ReactDOM.render(
React.createElement(
"div",
{ className: "demo" },
"Hello React",
React.createElement("input")
),
reactContainer
);На данный момент, если вы сомневаетесь, что мы делаем и думаем: «Это усложняет простой процесс», вы полностью правы! Но есть очень хорошая причина для того, что мы делаем. Продолжай читать.
Давайте также оказываем временную тему в обеих версиях. В версии JS давайте поместим временную метку в элемент абзаца. Мы можем использовать звонок на Новая дата () Для отображения простых временных меток:
jsContainer.innerHTML = `Hello JS`;${new Date()}
Чтобы сделать то же самое в реакции, мы добавляем 5-й аргумент на верхний уровень Div элемент. Этот новый 5-й аргумент – еще один Rect.Createelement Позвоните, на этот раз используя P Тег, без атрибутов, а Новая дата () Строка для содержимого:
ReactDOM.render(
React.createElement(
"div",
{ className: "demo" },
"Hello React",
React.createElement("input"),
React.createElement(
"p",
null,
new Date().toString()
)
),
reactContainer
);И версии JS, так и реагирования все еще отображают то же самое HTML в браузере.
Как видите, до сих пор использование реагирования на самом деле намного сложнее, чем простой и знакомый родной способ. Что реагирует так хорошо, это стоит отказаться от знакомого HTML и надо узнать новую API для написания того, что можно просто написать в HTML? Ответ не о рендере первого представления HTML, о чем нам нужно сделать, чтобы обновить любой существующий вид в DOM.
Итак, давайте сделаем операцию обновления на доме у нас до сих пор. Давайте просто сделаем метеостанцию отметку каждую секунду.
Мы можем легко повторить вызов функции JavaScript в браузере, используя Setinterval Интернет-таймер API. Итак, давайте поставим все наши манипуляции DOM для JS и React Versions в функции, называть его оказывать и используйте его в Setinterval Звоните, чтобы сделать его повторением каждую секунду.
Вот полный последний код в Script.js :
const jsContainer = document.getElementById("js");
const reactContainer = document.getElementById("react");
const render = () => {
jsContainer.innerHTML = `
Hello JS
${new Date()}
`;
ReactDOM.render(
React.createElement(
"div",
{ className: "demo" },
"Hello React ",
React.createElement("input"),
React.createElement(
"p",
null,
new Date().toString()
)
),
reactContainer
);
}
setInterval(render, 1000);Когда мы обновляем браузер сейчас, строка Timestamp должна быть отмечена каждую секунду в обеих версиях. Теперь мы обновляем наш пользовательский интерфейс в доме.
Это момент, когда реагирование потенциально поразит ваш разум. Если вы попытаетесь ввести что-то в текстовом поле версии JS, вы не сможете. Это очень ожидается, потому что мы в основном выбрасываем весь узел DOM на каждом тике и регенерируя его. Однако, если вы попытаетесь ввести что-то в текстовом поле, который отображается с реагированием, вы, безусловно, можете сделать это!
Хотя весь код рендеринга RACK находится в нашем таймере Ticking, Rect изменяет только пункт Timestamp, а не весь узел DOM. Вот почему окно ввода текста не было регенерировано, и мы смогли ввести его.
Вы можете увидеть различные способы, которыми мы визуально обновляем DOM, если вы проверяете два узла DOM в панели элементов DOM DEV. Инструменты Chrome Div подчеркивают любые элементы HTML, которые обновляются. Вы увидите, как мы восстанавливаем все «JS» DIV на каждом тике, в то время как Rect React – это просто только регенерация параграфа с строкой временной метки времени.
React имеет умный Рассеяться алгоритм, который он использует только регенерацию в своем узле DOM, что на самом деле нужно быть регенерированным, пока он держит все остальное, как есть. Этот различимый процесс возможен из-за реактивного виртуального дома и того факта, что у нас есть представление нашего пользовательского интерфейса в памяти (потому что мы написали в JavaScript).
Используя Virtual DOM, React сохраняет последнюю версию DOM в памяти, и когда она имеет новую версию DOM, чтобы взять в браузере, эта новая версия DOM также будет в памяти, поэтому Rection может вычислить разницу между новыми и старыми версиями (В нашем случае разница – это параграф Timestamp).
Затем отреагируйте браузеру обновлять только вычисленные разные, а не весь узел DOM. Независимо от того, сколько раз мы восстанавливаем наш интерфейс, отреагируйте в браузер только новые «частичные» обновления.
Этот метод не только намного более эффективен, но он также удаляет большой слой сложности для того, как мы Думаю Об обновлении пользовательских интерфейсов. Реагируйте все вычисления о том, должны ли мы обновить DOM или нет, позволяет нам сосредоточиться на мышлении о наших данных (штатах) и способом описания пользовательского интерфейса для него.
Затем мы управляем обновленными нашими данными по мере необходимости, не беспокоясь о шагах, необходимых для того, чтобы отразить эти обновления на фактическом пользовательском интерфейсе в браузере (потому что мы знаем, что реагирование сделает именно это, и это сделает это эффективным способом!)
Спасибо за прочтение! Вы можете просмотреть исходный код моего демо ;| здесь , и вы можете увидеть демонстрацию здесь Отказ
Изучение реагировать или узел? Оформить заказ моих книг: