Рубрики
Без рубрики

Руководство для начала работы с React

к Анкита Массанд Руководство для начинания начать работу с Reactin в этом руководстве, я сначала поможет вам понять, почему Facebook почувствовала необходимость построить библиотеку под названием React. Я охвачу все основные концепции, которые вам нужно для создания вашего первого приложения RACT. Это руководство

Автор оригинала: FreeCodeCamp Community Member.

Анкита Массанд

В этом руководстве я сначала поможет вам понять, почему Facebook почувствовал необходимость построить библиотеку под названием Реагировать Отказ Я охвачу все основные концепции, которые вам нужно для создания вашего первого приложения RACT. Это руководство направлено на объяснение реагированию, ясно, объяснив свои основы, как Использование JSX и ES6, создание компонентов STANDLOFLE & ACSALSES, элементы реагирования, виртуального дома и непрерывного алгоритма .

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

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

Например, рассмотрите раздел комментариев на Facebook. Данные комментариев привлечены к начальной нагрузке, добавляется к DOM. Теперь, когда вы добавляете новый комментарий, он делает асинхронный запрос на сервер, чтобы сохранить этот комментарий в базе данных и обновлять DOM, чтобы отразить текущее состояние.

Давайте попадаем в детали этого примера и понять, как это будет работать. Давайте скажем, что у меня есть 20 комментариев в моем массиве комментариев. Массив комментариев является источником правды, и он отражает текущее состояние в любой момент времени. Когда пользователь добавляет новый комментарий, нам необходимо изменить этот массив комментариев, как только новый комментарий был успешно добавлен в базу данных. Артикул комментариев теперь содержит 21 комментариев.

О да, нам также нужно написать код для обновления DOM, чтобы отразить текущее состояние (предположим, что мы используем здесь ванильный JavaScript или jQuery. Прохладные вещи, подходящие дальше!). Это означает, что контейнер Comments DOM подписан на массив комментариев. Он должен быть изменен, когда есть какие-либо изменения в массиве комментариев. Мы можем безопасно сказать, что массив комментариев здесь является моделью, а контейнер комментариев – вид.

Давайте добавим еще больше к этому – сотни элементов div подписаны на эту модель комментариев, что означает, что нам нужно написать код для обновления каждого из этих Div элементы.

function updateCommentsSubscriber (response) {    commentsArr = [ ...response ] // commentsArr = ['Comment 1', 'Comment 2', ...]    var firstDiv = document.getElementById('first')    firstDiv.innerHTML = commentsArr.length    var secondDiv = document.getElementById('second')    secondDiv.innerHTML = commentsArr.toString()    ...}

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

Facebook справился с проблемой масштабируемости и Дом Slowess, создавая библиотеку под названием Реагировать Отказ Реагистрация была впервые развернута на NewsFeed Раздел Facebook в 2011 году, а затем в Instagram в 2012 году. Он был открыт в 2013 году и был аплодирован сообществом по всему миру с тех пор.

В этом руководстве мы будем строить на основе реагирования. К концу этого урока вы должны быть в состоянии написать ваше первое приложение RACT.

Оглавление

  1. Внедрение реагирования
  2. Jsx.
  3. ES6
  4. Реактивные элементы
  5. Компоненты
  6. Штат и реквизит
  7. Компоненты без гражданства
  8. Методы жизненного цикла
  9. Виртуальный домос
  10. Создание вашего первого приложения RACT APP с использованием приложения Create-React-App

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

Внедрение реагирования

React – это библиотека JavaScript, используемая для построения пользовательских интерфейсов . Это решает проблему масштабируемости, упомянутую ранее, эффективно обновляя DOM.

Один из способов обновления DOM – это вручную вручную в соответствующих узлах DOM, что, очевидно, медленно и не масштабируемо.

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

С другой стороны, React предоставляет другой подход к решению этой проблемы. Он использует технику под названием Примирение Чтобы оценить разницу в представлении DOM в два пункта во времени. Это только обновляет часть, которая изменена. Это станет ясно, как только мы попадем в детали того, как работает Рейкт. На данный момент давайте рассмотрим простой пример:

Это входит в HTML:

Поместите код ниже в файле JavaScript:

class HelloReact extends React.Component {    render () {        return (            
Hello React!
        )    }}ReactDOM.render(, document.getElementById('app'))

Приведенный выше пример будет печать Привет отреагировать! на экране. HelloReact называется Компонент в реакции. оказывать Метод внутри этого компонента возвращает представление DOM.

Это не совпадение, которое я написал HTML в JavaScript.

Привет реагировать!
> Я Nidde Render Метод это синтаксис JSX. Это позволяет нам написать HTML в JavaScript.

Последнее утверждение делает работу о оказании HelloReact Компонент внутри нашего приложение контейнер. В следующих двух разделах мы погрузимся глубже в JSX и ES6.

Jsx.

Если у нас не было JSX, вам придется написать вышеуказанный код JSX как:

React.createElement("div", null, "Hello React!")

Это может осложнить вещи, если вам нужно иметь дело с вложенными элементами.

Например:

React.createElement("div", { className: "container" },    React.createElement("span", null, "Hello React!"),    React.createElement("span", null, "I'm inside HelloReact Component"))

И это синтаксис JSX для вышеуказанного кода:

    Hello React!    I'm inside HelloReact Component

Написание JSX внутри компонента реагирования дает четкое представление о том, что компонент собирается представлять до DOM. Это выглядит чистым и интуитивным.

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

JSX – это просто расширение JavaScript, которое позволяет написать HTML-похожий код:

Hello {name}!

Выражение внутри фигурных скобок будет оцениваться до значения переменной Имя Отказ Вы можете даже вызывать функции внутри JSX:

Hello, {formatName('james.gosling')!}

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

Условные заявления

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

Это может быть достигнуто с помощью JSX как:

greetUser (userName) {    if (isUserLoggedIn) {        return 
Hello, {userName}!
    }    return 
Hello, Guest!
}

Вышеуказанный пример будет приветствовать в системе пользователя с его именем и как Гость Когда пользователь не вошел в систему.

Обратите внимание, что этот условный рендеринг не похож на сценарий Show/Shower. На основании значения переменной Isuserloggedin Только один из двух элементов будет отображаться на DOM одновременно.

Рендеринг детских узлов с использованием функции карты

Давайте рассмотрим наши комментарии пример сверху. Здесь у нас есть комментарий Array, и нам нужно сделать все комментарии в контейнере DOM.

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

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

renderComments (commentsArr) {    /* commentsArr would look similar to this structure below    commentsArr = [{        id: 1,        text: "I'm a comment!"    }]    */    return (        
            {                commentsArr.map (function (comment) {                   return 
{comment.text}
                })            }        
    )}

Вышеуказанное рендеремменты Метод вернет результат карта метод. В этом случае карта Возвращает массив узлов DOM.

Обратите внимание на использование ключ с каждым Div элемент. Мы попадем в детали использования ключ с элементами DOM позже. На данный момент он просто используется в качестве способа для однозначно идентификации элементов DOM.

Компиляция JSX для JavaScript

Библиотека RACT не понимает JSX. Это просто используется для облегчения работы разработчика. Итак, что реагирует, когда он сталкивается с этим странным HTML-подобный Синтаксис в коде JavaScript?

JSX транспортируется к операторам JavaScript по Babel плагин прежде чем реагировать их. Транспиляция – это процесс преобразования одного языка источника на другой Отказ Итак, все, что Regact видит, является простым операторам JavaScript.

Простой код JSX сверху

Hello React!

транспилируется на

React.createElement("div", { className: 'heading' }, "Hello React!")

творчество Метод определяется на реакции.

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

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

Обратите внимание на использование классное значение вместо обычного Класс атрибут. В реакции, Класс Атрибут указан как классное значение Чтобы избежать конфликтов с существующими атрибутами.

Третий аргумент несет информацию о детях узла DOM. В этом случае это просто простой текст, который будет добавлен как innerhtml к узлу DOM

творчество Метод аналогичен Document.Createlement Метод в JavaScript, но он выводит реактивный элемент. Мы перейдем к деталям реактивных элементов позже.

ES6

ES6 – это аббревиатура для ECMAScript 6 или Ecmascript 2015. В этой части мы узнаем некоторые распространенные методы ES6, которые делают развивающиеся компоненты реагирования более простым заданием.

Пусть и const.

Пусть используется для объявления переменных на уровне блока, а Const используется для объявления констант. JavaScript следует за Уровень функции Scoping Отказ

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

Давайте рассмотрим пример, который поможет нам понять на уровне функции Scoping:

function pokemon (id) { //id = 12    if (id === 12) {        var pokemonObj = {            id: 12,            name: 'butterfree',            height: 11,            weight: 22,            abilities: [                {                    name: 'tinted-lens'                }            ]        }    }    return pokemonObj    }

Вышеуказанное покемон Метод берет ID Как параметр, и возвращает покемонов Если ID равно 12 Отказ Продолжайте и запустите эту функцию в консоли браузера.

Если вы выполняете Покемон (12) он печатает Покемонов как и ожидалось. Однако, если вы выполняете Pokemon (13) , это не отображает ошибку, а вместо отпечаток undefined Отказ

Обратите внимание, что Покемонов определяется в Если построить, что означает, что если я D не равно 12, Покемонов не должен быть доступен в контексте покемон функция.

JavaScript следует на уровне функционального уровня, что означает, что переменная, объявленная в любом операторе внутри функции, доступна на протяжении всей функции. Итак, Покемонов доступен, даже если он объявлен внутри Если блокировать.

Пусть Конструкция решает эту проблему, поскольку она позволяет нам ограничить объем переменных на уровень блокировки.

Использовать Пусть для объявления Покемонов и проверьте результаты:

function pokemon (id) { //id = 12    if (id === 12) {        let pokemonObj = {            id: 12,            name: 'butterfree',            height: 11,            weight: 22,            abilities: [                {                    name: 'tinted-lens'                }            ]        }    }    return pokemonObj    }

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

Переменная объявлена с использованием Const не может быть изменен:

const POKEMON = 'butterfree' pokemon = 'pikachu'

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

Разрушение объекта

Рассмотрим объект, Ягоды , которые являются небольшими фруктами, которые могут обеспечить восстановление состояния HP и состояние статуса, улучшение статистики и даже отрицание урона при съеде покемонов:

var berries = {    id: 1,    name: 'cheri',    growth_time: '3',    max_harvest: 5,    natural_gift_power: 60,    size: 20,    smoothness: 25,    soil_dryness: 15,    natural_gift_type: {        name: 'fire',        url: 'https://pokeapi.co/api/v2/type/10/'    }}

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

var id = berries.idvar name = berries.namevar growthTime = berries.growth_time

А с ES6:

let { id, name, growth_time, max_harvest, natural_gift_power, size } = berries

Вышеуказанное заявление создает локальные переменные как ID , имя , ROIST_TIME С max_harvest С natural_gift_power и Размер И каждый из них будет иметь значение, соответствующую этому в Ягоды объект. Разве это не круто?

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

Струнная шаблона

Вот старый способ объединения строк в JavaScript:

var cheriDescription = "One of the berries is " + name + ". Its growth time is " + growth_time + ". Its size is " + size + ". Its Max Harvest is " + max_harvest.

И вот ES6 Way:

let cheriDescription = `One of the berries is ${name}. Its growth time is ${growth_time}. Its size is ${size}. Its Max Harvest is ${max_harvest}.`

Вы можете написать все предложение в Backticks без необходимости объединения статического текста и переменных в частях. Оберните переменные внутри '$ {}' Отказ Это выглядит намного чище.

Функции стрелки

Это мой любимый. Ниже приведен старый способ написания функций в JavaScript:

function getBerrySize (berries) {    return berries.size}

И это способ написания функций ES6:

const getBerrySize = (berries) => berries.size

Функции стрелки Следуйте этим синтаксисом:

Декларация Функциональное значение = (FunctionParams) = & g t; вернуть res ультра

Вышеуказанная функция getberrysize Возвращает размер ягоды. Обратите внимание, что мы не написали слово возвращение в приведенной выше функции стрелки. Использование Возвращение Необязательно, если корпус функции стрелки имеет только одно утверждение, и он возвращает это утверждение.

Если функциональное тело имеет более одного оператора, оберните их в фигурных скобках.

Функции стрелки ведут себя немного по сравнению с обычными функциями при использовании с это построить. Узнайте больше о это И как функции стрелки ведут себя по-разному при использовании с это из моей статьи здесь .

Классы

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

Давайте построим класс для оценки ягод:

class Berries {    constructor (berries) {        this.berries = berries    }    getSize () {        return this.berries.size    }    getGrowthTime () {        return this.berries.growth_time    }}const cherries = new Berries(berries)cherries.getSize() // 20cherries.getGrowthTime() // 3

Мы завернули соответствующие методы ягод внутри класса Ягоды Отказ

Утверждение Const ягоды (ягоды) Значения класса ягод и создайте объект типа Ягоды Отказ

Вход, переданный в конструктор ягод, это ягоды объект, который мы создали ранее. Мы можем использовать методы, определенные в Ягоды Класс на этом объекте.

Теперь, когда мы узнали большинство общих методов ES6, мы можем использовать их в следующих разделах.

Реактивные элементы

Элементы React – самые маленькие единицы, которые представляют собой состояние дома в любой момент времени.

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

С этим утверждением:

React.createElement("div", { className: 'heading' }, "Hello React!")

Div Узел DOM еще не добавлен до DOM. Вышеуказанное утверждение преобразуется в простой объект JavaScript AS:

{    type: 'div',    props: {        className: 'heading',        children: 'Hello React!'    }}

Эти объекты называются Реактивные элементы Отказ

Они содержат два важных ключа:

Тип Определяет тип узла DOM. Это может быть Div , охватывать , P , и так далее.

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

Вложенные элементы могут быть указаны в качестве значения дети ключ.

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

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

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

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

Реактировать использует Рассеяться Алгоритм, чтобы узнать, что нужно обновить до DOM. Мы узнаем больше об этом в разделе Virtual DOM.

Давайте пройдемся через то, что мы узнали до сих пор:

  • JSX – это HTML-подобный Синтаксис, который используется в компонентах реагирования. Это просто представление узла DOM и на самом деле не добавляет элементы до DOM.
  • Плагин Babel транкирует его до простых операторов JavaScript, как Rect.Createelement Отказ
  • Rect.Createelement Заявления дополнительно преобразуются в объекты JavaScript.
  • Реантрез эффективно обновляет реальный DOM, используя объекты, созданные выше.

Компоненты

Компоненты являются многоразовыми классами, которые определяют определенную функциональность. Реагистрация следует за Компонент на основе состав. Каждый из компонентов, которые мы определяем в реакцию, расширяют основные функциональные возможности нативного реагистрационного компонента.

Давайте создадим простой реагирующий компонент для входного текста:

class Text extends React.Component {    state = {        value: ''    }    onChange = (e) => {        this.setState({ value: e.target.value })    }    render () {        return (                    )    }}export default Text

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

Атрибуты – текст , Onchange и ценить которые передаются на вход Элемент называется реквизит в реакции. Onchange это обработчик событий, который вызывается всякий раз, когда значение текста в поле ввода изменяется. реквизит в реакции только чтение.

Компоненты реагирования поддерживают внутреннее состояние для обработки сложности на основе различных параметров. В начале нашего компонента мы инициализировали объект под названием Государство Отказ Эта переменная состояния обрабатывает состояние текстового компонента. Состояние может быть изменено с использованием SetState Метод, как показано в Onchange метод определен выше.

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

Давайте создадим компонент форм, который импортирует текстовый компонент сверху:

import Text from './text'class Forms extends React.Component {    state = {}    render () {        return (            
                
Form for basic details
                            
        )    }}

Во-первых, мы импортируем текстовый компонент. Обратите внимание, как текстовый компонент включен в оказывать Способ компонента форм.

Когда компонент форм отображается, <Текст /> заменяется за счет возврата F Рендер метода в текстовом компоненте.

Подробнее о состоянии и реквизитах

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

Давайте изменим оказывать способ вышеупомянутых форм компонента как

render () {    return (        
            
Form for basic details
            ;        
    )}

Обратите внимание, как мы проезжаем Тип реквизит в текстовом компоненте.

Нам нужно внести изменения в наш текстовый компонент, чтобы принять эти реквизиты.

Проверьте изменения в оказывать Метод:

render () {    let { type } = this.props    return (            )}

реквизит Пропущенные компонентами форм доступны в качестве объекта в текстовом компонент. Обратите внимание, как мы используем Тип Свойство в текстовом компонент, который был передан компонентом форм.

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

Государство Это не что иное, как объект JavaScript. Это можно изменить с помощью SetState метод. SetState Метод принимает объект в качестве ввода. Всякий раз, когда какая-либо значение изменяется в состоянии, мы передаем только это значение в SetState Метод вместо прохождения всего состояния объекта.

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

Если есть изменение в ROIST_TIME Собственность ягоды Объект, мы можем обновить его в штате как:

this.setState({ growth_time: new_growth_time })

Мы не проходим весь Ягоды объект к SetState метод. Мы передаем только значение, которое необходимо обновить.

SetState Способ работает как асинхронная функция. Несколько государственных вызовов обновлений насыщены и вызываются вместе с более поздними интервалами для решения проблем с производительностью.

Компоненты без гражданства

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

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

Давайте посмотрим на пример компонента без гражданства:

const getBerrySize = (props) => {    let { size } = props    return (        
{size}<;/p>    )}

Единственная работа этого компонента – вернуть представление DOM для отображения размера ягод.

Компонентный жизненный цикл

Компонент React следует за определенным рисунком жизненного цикла. Это проходит через четыре важных этапа:

  1. Инициализация
  2. Монтаж
  3. Обновление
  4. Отключение

Давайте посмотрим на некоторые из методов, которые вызываются во время этих фаз

Инициализация Инициализировать состояние и реквизиты.

Монтаж ComponentWillmount – Этот метод вызывается непосредственно перед воздействием монтажа. Это называется до оказывать метод. Для установки начального состояния и реквизита рекомендуется использовать Конструктор вместо этого метода.

оказывать – Это единственный требуемый метод в компоненте класса. Он возвращает представление DOM в любой момент времени. Осуществляется значение Государство и реквизит и возвращает обновленное представление DOM.

ComponentDidmount – Этот метод вызывается сразу после установки компонента. Это хорошее место для интерактивных сетевых запросов на сервер. Как только данные загружены с сервера, вы можете позвонить SetState Способ вызывать оказывать Для обновления узлов DOM.

Обновление ComponentWillReceiveProps – Если есть какие-либо изменения в реквизит Этот метод называется для рендеринга обновленного состояния. Не рекомендуется использовать этот метод от React версии 16 на.

должен быть необходим – Если этот метод возвращает правда , оказывать Метод называется, чтобы освободить место для обновленного Государство и реквизит .

ComponentWillUpdate – Этот метод немедленно вызывается, прежде чем рендеринг начинает выполнять свою работу.

ComponentDidupdate – Этот метод вызывается, как только обновленное состояние отображается на DOM.

Размонтирование ComponentWillunmount – Этот метод вызывается непосредственно перед размонтированием компонента. Это хорошее место для удаления любых подписок от компонента.

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

Виртуальный домос

Я упомянул проблему масштабируемости ранее при введении реагирования. В этом разделе мы увидим, как реагирует эффективно решает эту проблему.

От того, что вы узнали до сих пор, понятно, что ReCv не напрямую обновляет реальный DOM. Все React знают, что DOM – это не что иное, как объект JavaScript. Этот гигантский объект JavaScript называется Виртуальный Дом Отказ

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

Как упоминалось ранее, Rection использует методику под названием Примирение Чтобы оценить разницу между настоящим домом и виртуальным домом.

Примирение – это действие сделать одно мнение или убеждение, совместимую с другим Отказ И это именно то, что реагирует. Он вносит изменения в реальное домо, чтобы сделать его совместимым с текущим состоянием виртуального дома. Реактировать использует Рассеяться Алгоритм для оценки изменений, которые должны быть сделаны в настоящий дом.

Он использует эвристический алгоритм, который основан на двух допущениях:

  1. Два элемента разных типов будут производить разные деревья
  2. Устойчивые элементы или элементы, которые не изменяются, идентифицированы с использованием уникального идентификатора, называемого ключ Отказ

Элементы разных типов

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

Например, если тип корня в реальном доме был Div И тот, кто в виртуальном доме был охватывать Дифференциальный алгоритм будет стереть весь Div Контейнер от настоящего дома.

Дом элементы того же типа

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

Рассмотрим этот узел DOM в реальном доме:

React Diffing Algorithm

Теперь рассмотрим обновленный узел DOM, который является выходом оказывать Способ некоторых компонентов:

React Diffing Algorithm

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

Определение положения детей в родительском контейнере

Реагируйте рекомендуют использовать ключ Опора, если подобные дети должны быть добавлены к определенному узлу DOM.

Давайте рассмотрим пример комментариев Array:

commentsArr.map (comment => {    return 
{comment.text}
})

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

Начало работы с реагированием, используя Create-React-App

Create-React-App Это инструмент интерфейса командной строки RACT, который используется для создания исходной котельной для любого приложения React.

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

npm i create-react-app -g

Это устанавливает Create-React-App Модуль узла во всем мире на вашей системе.

Команда Create-ract-app my-app Создает реактивный проект внутри My-App каталог. Играйте с файлами и попробуйте построить меньший реагировать компонент.

Я надеюсь, что у вас теперь есть идея того, что реагирует и как его использовать.

Давайте повторим, что мы узнали до сих пор

  1. Мы видели, что обновление узлов DOM, используя RAW JavaScript Code не масштабируемым.
  2. РЕАКТ – это библиотека JavaScript для построения пользовательских интерфейсов. Это решает проблему масштабируемости путем эффективного обновления DOM.
  3. Реагистрационные компоненты выходные представления DOM в виде JSX. JSX – это просто синтаксический сахар, который используется для облегчения работы развития. Он транспилируется на операторы JavaScript в форме Rect.Createelement Отказ
  4. Мы узнали о большинстве распространенных методов ES6, таких как использование позволять и конститут , Деструктурирование объектов, классы, функции стрелки и шаблон строки. Они используются при написании компонентов реагирования.
  5. Мы узнали о реактивных элементах и как они созданы.
  6. Мы узнали, что реагистрация следует за шаблоном на основе компонентов и о том, как она использует композицию для создания сложных компонентов, использующих простые. Компонент использует Государство и реквизит для обработки внутреннего состояния.
  7. Мы глубоко погрузились в то, как React создают виртуальный дом, а также понимают базовый расследующий алгоритм, который используется для эффективного обновления реального домена.

В следующей серии статей о реагировании я буду охватывать следующие темы более подробно:

  1. Жизненный цикл реагирования
  2. Виртуальный домос
  3. Начало работы с реакцией, используя Create-React-App

Первоначально опубликовано hashnode.com .

Оригинал: “https://www.freecodecamp.org/news/a-beginners-guide-to-getting-started-with-react-c7f34354279e/”

Читайте ещё по теме: