<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Владимир Голотин on Medium]]></title>
        <description><![CDATA[Stories by Владимир Голотин on Medium]]></description>
        <link>https://medium.com/@uncleseneca?source=rss-547898b45720------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*iEGMuNVuFaob632v3eTwEg.jpeg</url>
            <title>Stories by Владимир Голотин on Medium</title>
            <link>https://medium.com/@uncleseneca?source=rss-547898b45720------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 23:23:58 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@uncleseneca/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Полная реактивность: подробное объяснение работы MobX]]></title>
            <link>https://medium.com/breadhead-stories/%D0%BF%D0%BE%D0%BB%D0%BD%D0%B0%D1%8F-%D1%80%D0%B5%D0%B0%D0%BA%D1%82%D0%B8%D0%B2%D0%BD%D0%BE%D1%81%D1%82%D1%8C-%D0%BF%D0%BE%D0%B4%D1%80%D0%BE%D0%B1%D0%BD%D0%BE%D0%B5-%D0%BE%D0%B1%D1%8A%D1%8F%D1%81%D0%BD%D0%B5%D0%BD%D0%B8%D0%B5-%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D1%8B-mobx-9a47f6d4cab2?source=rss-547898b45720------2</link>
            <guid isPermaLink="false">https://medium.com/p/9a47f6d4cab2</guid>
            <category><![CDATA[разработка]]></category>
            <category><![CDATA[mobx]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[программирование]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Владимир Голотин]]></dc:creator>
            <pubDate>Wed, 14 Aug 2019 20:43:43 GMT</pubDate>
            <atom:updated>2019-08-14T20:43:43.453Z</atom:updated>
            <content:encoded><![CDATA[<p>Это перевод статьи <a href="https://medium.com/@mweststrate?source=post_page-----55995262a254----------------------">Michel Weststrate</a> <a href="https://medium.com/hackernoon/becoming-fully-reactive-an-in-depth-explanation-of-mobservable-55995262a254">Becoming fully reactive: an in-depth explanation of MobX</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/565/1*7zMuahy5VEqzR-qFLilfkQ.png" /></figure><p>В связи с большим спросом (и для того, чтобы рассказать крутую историю своим внукам) написал статью о внутренней работе MobX. Многих удивляет последовательность и скорость его работы. Но будьте уверены, здесь нет никакой магии!</p><p>Сначала давайте определимся с основными терминами:</p><ol><li><strong>Наблюдаемое состояние (observable state)</strong>. Любое значение, которое может быть изменено и может служить источником для вычисленных значений, является состоянием. MobX может сделать большинство типов значений (примитивы, массивы, классы, объекты и т.д.) и даже (потенциально циклические) ссылки наблюдаемыми из коробки.</li><li><strong>Вычисленные значения (computed values)</strong>. Любое значение, которое может быть вычислено с помощью функции, использующей исключительно другие вычисленные значения. Вычисленные значения могут варьироваться от конкатенации нескольких строк до получения сложных объектов и визуализаций. Поскольку вычисленные значения являются наблюдаемыми сами по себе, даже отображение всего пользовательского интерфейса может быть выведено из наблюдаемого состояния. Вычисленные значения могут быть рассчитаны либо лениво, либо как реакция на изменения состояния.</li><li><strong>Реакции (reactions)</strong>. Реакция немного похожа на вычисленное значение, но вместо того, чтобы произвести новое значение, она дает побочный эффект. Реакции соединяют реактивное и императивное программирование для таких вещей, как вывод в консоль, выполнение сетевых запросов, инкрементальное обновление дерева компонентов React для обновления DOM и т.д.</li><li><strong>Экшны (actions)</strong>. Экшны являются основным средством изменения состояния. Экшны не являются реакцией на изменения состояния, а берут источники изменений, такие как пользовательские события или входящие соединения через веб-сокеты, для изменения наблюдаемого состояния.</li></ol><p>Вычисленные значения и реакции называются <strong>производными</strong> в оставшейся части этой статьи. Пока все это может показаться немного академичным, так что давайте добавим конкретики! В электронной таблице все ячейки данных, имеющие значения, будут формировать наблюдаемое состояние. Формулы и графики представляют собой расчетные значения, которые могут быть получены из ячеек данных и других формул. Вывод ячейки данных или формулы на экран является реакцией. Изменение ячейки данных или формулы — это действие.</p><p>В любом случае, вот все четыре понятия в маленьком примере, использующем MobX и React:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/60b0af34eec72000dfce74b84fd13a05/href">https://medium.com/media/60b0af34eec72000dfce74b84fd13a05/href</a></iframe><p>Мы можем нарисовать дерево зависимостей на основе приведенного выше списка. Интуитивно это будет выглядеть следующим образом:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/535/1*VRwzBYB805gpNQPSNwx8Rg.png" /><figcaption>Рисунок 1: Дерево зависимостей компонента profileView. FullName находится в реактивном режиме, активно наблюдая за именем и фамилией.</figcaption></figure><p><strong>Состояние</strong> этих приложений отображается в <strong>наблюдаемых</strong> свойствах (синий цвет). Зеленое <strong>вычисленное значение</strong> fullName может быть выведено из состояния автоматически путем наблюдения за именем и фамилией. Аналогично рендеринг profileView может быть получен из nickName и fullName. profileView будет реагировать на изменения состояния, создавая побочный эффект: он обновляет дерево компонентов React.</p><p>При использовании MobX дерево зависимостей имеет минимальный размер. Например, как только человек получает псевдоним, вывод значения fullName, первого имени или фамилии больше не будет влиять на рендеринг (см. рисунок 1). Все отношения наблюдателя между этими значениями могут быть очищены, и MobX автоматически упростит дерево зависимостей соответственно:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/535/1*YrW9P1iQ2cLTbpuIgMon2g.png" /><figcaption>Рисунок 2: Дерево зависимостей компонента profileView, если у пользователя есть псевдоним (см. рисунок 1). В отличие от рисунка 1, fullName теперь находится в ленивом режиме и не видит имени и фамилии.</figcaption></figure><h4>Reacting to state changes is always better then acting on state changes.</h4><h3>Michel Weststrate on Twitter</h3><p>Automatically updating application state is an anti-pattern. Derive data instead</p><p>Любое императивное действие, которое приложение делает в ответ на изменение состояния, обычно создает или обновляет некоторые значения. Другими словами, большинство действий управляют <a href="https://medium.com/@mweststrate/pure-rendering-in-the-light-of-time-and-state-4b537d8d40b1">локальным кэшем</a>. Запуск обновления пользовательского интерфейса? Обновление агрегированных значений? Все это можно считать как замаскированная инвалидация кэша. Чтобы обеспечить синхронизацию этого кэша, вам нужно подписаться на будущие изменения состояния, которые позволят вам снова выполнить нужные действия.</p><p>Но работа с подписками (или курсорами, линзами, селекторами, коннекторами и т.д.) имеет фундаментальную проблему: по мере развития вашего приложения вы будете совершать ошибки в управлении этими подписками и либо переподписываться (продолжать подписку или сохранять значения, которые больше не используются в компоненте), либо отказываться от подписки (забывая слушать обновления).</p><h4>Другими словами, при использовании подписок вручную ваше приложение в конечном итоге будет непоследовательным.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/785/1*eEeW2q_6W3riMc1fId1yvQ.png" /><figcaption>Рисунок 3: Несогласованная страница Twitter после обновления профиля. В прикрепленном твите отображаются устаревшие значения как для имени автора, так и для его профиля.</figcaption></figure><p>Изображение выше является хорошим примером непоследовательности интерфейса Twitter. Как я уже говорил в своем докладе <a href="https://www.youtube.com/watch?v=FEwLwiizlk0">Reactive2015</a>, для этого могут быть только две причины: или отсутствует подписка у твитов, которая обновляет их при изменении данных об авторе. Или данные были нормализованы, и автор твита даже не имеет отношения к профилю текущего вошедшего в систему пользователя, несмотря на то, что обе части данных пытаются описать одни и те же свойства одного и того же человека.</p><p>Крупные подписки, в стиле Flux, очень чувствительны к переподписке (oversubscribing). Используя React, вы можете просто определить, переписываются ли ваши компоненты, <a href="https://reactjs.org/docs/optimizing-performance.html#profiling-components-with-the-chrome-performance-tab">логируя</a> ненужные рендеринги. <a href="https://www.mendix.com/blog/making-react-reactive-pursuit-high-performing-easily-maintainable-react-apps/">MobX уменьшит это число до нуля</a>. Идея проста, но не интуитивна: Увеличение числа подписок приводит к меньшему числу пересчетов. MobX управляет многими тысячами наблюдателей за вас. Вы можете эффективно обменять память на циклы процессора.</p><p>Обратите внимание, что переподписка также существует в очень интересных формах. Если вы подписываетесь на данные, которые используются, но не при всех условиях, вы все равно подписываетесь сверх нормы. Например, если компонент <strong>profileView</strong> подписывается на полное имя человека с <strong>nickName</strong>, то это переподписка (см. рисунок 1). Так что важным принципом дизайна MobX является принцип:</p><h4>Минимальный, согласованный набор подписок можно получить только в случае, если подписки определены в рантайме.</h4><p>Вторая важная идея за MobX заключается в том, что для любого приложения, более сложного, чем TodoMVC, вам часто нужен <strong>граф данных</strong>, вместо нормализованного дерева, чтобы хранить его мысленно управляемым, но оптимальным образом. Графики обеспечивают согласованность ссылок и исключают дублирование данных, что позволяет гарантировать, что получаемые значения никогда не будут устаревшими.</p><h4>Как MobX эффективно поддерживает все вычисления в согласованном состоянии</h4><p>Решение: не кэшировать, а вычислять. Люди спрашивают: “Разве это не слишком дорого?”. Нет, на самом деле это очень эффективно! Причина этого, как объяснялось выше: MobX не выполняет все вычисления, но обеспечивает синхронизацию с наблюдаемым состоянием только <strong>вычисленных значений</strong>, участвующих в той или иной<strong> реакции</strong>. Эти производные называются реактивными. Чтобы снова провести параллель с электронными таблицами: при изменении одной из наблюдаемых ячеек данных необходимо пересчитывать только те формулы, которые в данный момент видны или косвенно используются рассматриваемой формулой.</p><p><strong>Ленивое вычисление против реактивного вычисления. <br></strong>Так что насчет вычислений, которые не используются прямо или косвенно реакцией? Вы все еще можете в любое время проверить значение вычисленного значения, например fullName. Решение простое: если вычисленное значение не является реактивным, оно будет вычисляться по требованию (лениво), как и обычная функция-геттер. Ленивые производные (которые никогда ничего не наблюдают) могут быть просто мусором, если они выходят за рамки видимости. Помните, что вычисляемые значения всегда должны быть чистыми функциями наблюдаемого состояния приложения? Вот почему: Для чистых функций не имеет значения, лениво они выполняются или сразу: выполнение чистой функции всегда дает один и тот же результат при одном и том же наблюдаемом состоянии.</p><p><strong>Выполнение вычислений</strong><br>Реакции и вычисленные значения выполняются MobX одним и тем же способом. При повторном запуске вычислений функция добавляется в стек вычислений: стек функций, в котором в данный момент выполняются вычисления. Пока вычисления выполняются, каждый наблюдаемый объект, к которому осуществляется доступ, регистрируется как зависимость от самой верхней функции вычислительного стека. Если требуется значение вычисленной величины, то она может быть последней известной величиной, если вычисленная величина уже находится в реактивном состоянии. Иначе он будет толкать себя на производный стек, переключаться в реактивный режим, а также запускать вычисления.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/641/1*eF9TJlR1om_MeT-g_FlszA.png" /><figcaption>Рисунок 4: В процессе выполнения реакции profileView наблюдается некоторое наблюдаемое состояние и некоторые вычисленные значения. Вычисленные значения могут быть пересчитаны, в результате чего появится дерево зависимостей, как показано на рисунке 1.</figcaption></figure><h4>Распространение изменения состояния</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/435/1*gOVz9PhIbDQ2qK-KtZ7pug.png" /><figcaption>Рисунок 5: Влияние изменения значения ‘1’ на дерево зависимостей. Пунктирная граница обозначает наблюдателей, которые будут помечены как неработающие. Цифры указывают порядок вычислений.</figcaption></figure><p>Производные будут автоматически реагировать на изменения состояния. Все реакции происходят синхронно и, что более важно, без сбоев. При изменении наблюдаемого значения выполняется следующий алгоритм:</p><ol><li>Наблюдаемый объект посылает всем своим наблюдателям уведомление о том, что он стал устаревшим. Любые затрагиваемые вычисленные значения будут рекурсивно передаваться своим наблюдателям. В результате часть дерева зависимостей будет помечена как устаревшая. В примере дерева зависимостей на рисунке 5 наблюдатели, которые устареют при изменении значения “1”, отмечены оранжевой пунктирной линией. Это все производные, на которые может повлиять изменение значения.</li><li>После отправки уведомления об устаревших данных и сохранения нового значения, будет отправлено уведомление о готовности. Это уведомление также указывает на то, действительно ли изменилось значение.</li><li>Как только производная получит уведомление о готовности для каждого уведомления об устаревших данных, полученного в шаге 1, она будет знать, что все наблюдаемые значения стабильны и начнет перерасчет. Подсчет количества готовых/устаревших уведомлений гарантирует, что, например, вычисленное значение “4” будет пересматриваться только после того, как вычисленное значение “3” станет стабильным.</li><li>Если ни одно из уведомлений о готовности не указывает на то, что значение было изменено, то производная просто скажет собственным наблюдателям, что она снова готова, но без изменения своего значения. В противном случае вычисления будут пересчитаны и отправят собственным наблюдателям уведомление о готовности. В результате получается такой порядок выполнения, как показано на рисунке 5. Обратите внимание, что последняя реакция (помеченная символом “-”) никогда не будет выполнена, если вычисленное значение “4” действительно пересчитано, но не дало нового значения.</li></ol><p>В предыдущих двух абзацах кратко описано, как отслеживаются зависимости между наблюдаемыми значениями и производными во время выполнения и как изменения распространяются через производные. В этот момент вы также можете понять, что реакция — это, по сути, вычисленное значение, которое всегда находится в реактивном режиме. Важно понимать, что этот алгоритм может быть реализован очень эффективно без замыканий и только с помощью множества массивов указателей. Кроме того, MobX применяет ряд других оптимизаций, которые выходят за рамки данной заметки в блоге.</p><h4>Синхронное выполнение</h4><p>Люди часто удивляются, что MobX работает все синхронно (как RxJ и в отличие от knockout). Это имеет два больших преимущества: Первым делом становится просто невозможным когда-либо наблюдать за устаревшими производными. Таким образом, производная величина может быть использована сразу же после изменения величины, которая влияет на нее. Во-вторых, это упрощает отладку и стэк-трейсинг, так как позволяет избежать бесполезных стэк-трейсов, типичных для библиотек Promise / async.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b9cab0061d270678584dc777b6b6ff06/href">https://medium.com/media/b9cab0061d270678584dc777b6b6ff06/href</a></iframe><p>Однако синхронное исполнение также вводит необходимость в транзакциях. Если сразу несколько мутаций применяются сразу несколько раз подряд, то после применения всех изменений предпочтительнее провести повторное вычисление всех производных. Обертывание действия в блок транзакции позволяет достичь этого. Транзакции просто откладывают все готовые уведомления до тех пор, пока не будет завершен блок транзакций. Обратите внимание, что транзакции все еще выполняются и обновляются синхронно.</p><p>Это наиболее важные детали реализации MobX. Мы еще не все рассмотрели, но хорошо знать, например, что вы можете использовать композицию вычисленных значений. Композируя реактивные вычисления, можно даже автоматически преобразовывать один граф данных в другой граф данных и поддерживать его в актуальном состоянии с минимальным количеством изменений. Это упрощает реализацию сложных шаблонов, таких как отображение карты, отслеживание состояния с использованием неизменяемых общих данных или загрузка данных от бэкенда. Но подробнее об этом в следующей статье.</p><h3>TL;DR:</h3><ol><li>Состояние сложных приложений лучше всего можно выразить с помощью графов, чтобы добиться референтной согласованности и оставаться близко к ментальной модели предметной области.</li><li>Не следует в обязательном порядке реагировать на изменения состояния с помощью подписок или курсоров, определяемых вручную. Это неизбежно приведет к ошибкам в результате недостаточной или избыточной подписки.</li><li>Используйте анализ в рантайме для определения наименьшего возможного набора наблюдатель → наблюдаемые связи. Это приводит к построению вычислительной модели, в которой можно гарантировать, что минимальное количество производных будет вычислено без какого-либо наблюдения за устаревшим значением.</li><li>Любая производная, которая не нужна для достижения активного побочного эффекта, может быть полностью оптимизирована.</li></ol><p>Ещё ссылки про MobX:</p><ol><li>Мой доклад на <a href="https://www.youtube.com/watch?v=FEwLwiizlk0">Reactive2015</a></li><li><a href="https://mobx.js.org/">Официальный сайт</a> и <a href="https://github.com/mobxjs/mobx">репозиторий</a></li><li>Бойлерплейт: <a href="https://github.com/mweststrate/mobservable-react-boilerplate">React + Babel</a>, <a href="https://github.com/mweststrate/mobservable-react-typescript">React + TypeScript</a>, <a href="https://github.com/mweststrate/todomvc/tree/master/examples/react-mobservable">TodoMVC</a> или <a href="https://github.com/staltz/flux-challenge/blob/master/submissions/mweststrate/index.tsx">Flux-Challenge</a></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9a47f6d4cab2" width="1" height="1" alt=""><hr><p><a href="https://medium.com/breadhead-stories/%D0%BF%D0%BE%D0%BB%D0%BD%D0%B0%D1%8F-%D1%80%D0%B5%D0%B0%D0%BA%D1%82%D0%B8%D0%B2%D0%BD%D0%BE%D1%81%D1%82%D1%8C-%D0%BF%D0%BE%D0%B4%D1%80%D0%BE%D0%B1%D0%BD%D0%BE%D0%B5-%D0%BE%D0%B1%D1%8A%D1%8F%D1%81%D0%BD%D0%B5%D0%BD%D0%B8%D0%B5-%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D1%8B-mobx-9a47f6d4cab2">Полная реактивность: подробное объяснение работы MobX</a> was originally published in <a href="https://medium.com/breadhead-stories">Breadhead Stories</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Анимированные роуты в React]]></title>
            <link>https://medium.com/breadhead-stories/%D0%B0%D0%BD%D0%B8%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D1%8B%D0%B5-%D1%80%D0%BE%D1%83%D1%82%D1%8B-%D0%B2-react-c492268772e9?source=rss-547898b45720------2</link>
            <guid isPermaLink="false">https://medium.com/p/c492268772e9</guid>
            <category><![CDATA[react-spring]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[react-router]]></category>
            <dc:creator><![CDATA[Владимир Голотин]]></dc:creator>
            <pubDate>Mon, 24 Jun 2019 15:59:12 GMT</pubDate>
            <atom:updated>2019-06-24T15:59:12.276Z</atom:updated>
            <content:encoded><![CDATA[<h3>Анимированные переходы между страницами в React</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DJrWZ2KvogUID5JNJFC02Q.jpeg" /></figure><p>React плохо приспособлен для анимаций компонентов. Без дополнительных ухищрений компонент не будет ждать завершения анимации при удалении из дерева. Как раз это происходит при роутинге — один роут заменяет другой при переходе на страницу.</p><p>К счастью, существует много библиотек, которые облегчают эту задачу. Одна из них — <a href="https://www.react-spring.io/">react-spring</a>.</p><p>Для анимации роутов в React нужно знать несколько подводных камней, которые мы сегодня рассмотрим. Использовать будем популярный react-router. Создадим компонент, который возвращает Switch и содержит несколько роутов:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d0e60d145e6a33c7e88aaffde01c2a3a/href">https://medium.com/media/d0e60d145e6a33c7e88aaffde01c2a3a/href</a></iframe><p>Теперь добавим обвязку react-spring:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/90c96f1227ca4b9fc03595d797dda5e5/href">https://medium.com/media/90c96f1227ca4b9fc03595d797dda5e5/href</a></iframe><p>Давайте разберемся по порядку:</p><ol><li><strong>useRouter</strong> — хук, который получаем, используя useContext и <strong>__RouterContext</strong> — вспомогательный компонент react-router.</li><li><strong>useTransition</strong> — хук react-spring, который помогает анимировать компоненты, которые удаляются и добавляются</li></ol><p>Первым аргументов в <strong>useTransition</strong> передаем объект <strong>location</strong>, который содержит всю информацию о роутинге. Этот объект мы увидим в рендер методе под именем <strong>item </strong>и передадим его в компонент <strong>Switch. </strong>Это нужно, чтобы <strong>Switch </strong>получал информацию о роутинге не из браузера, а через пропсы. Так мы сможем синхронизировать <strong>react-spring</strong> и <strong>react-router</strong>.</p><p>Вторым аргументом передаем функцию, которая принимает <strong>item (location) </strong>и возвращает <strong>location.key </strong>— уникальный ключ для каждого роута.</p><p>Третьим аргументом передаем параметры анимаций <strong>from, enter и leave</strong></p><p><strong>from</strong> — стили компонента, который добавляется в дерево<br><strong>enter</strong> — стили компонента, который добавился в дерево<br><strong>leave</strong> — стили компонента, который удаляется из дерева</p><p>3. <strong>transitions</strong> — массив объектов, каждый из которых состоит из</p><p><strong>item</strong> — первый аргумент, который мы передавали в <strong>useTransition<br>props (transition)</strong> — стили анимаций<br><strong>key</strong> — то, что вернула функция <strong>location</strong> =&gt; <strong>location.key</strong></p><p>Передаем <strong>key</strong> и <strong>transition</strong> в <strong>animated.div</strong> для улучшенной производительности и передаем item в <strong>Switch</strong>, чтобы синхронизировать <strong>react-router</strong> <strong>react-spring</strong></p><p>В результате мы получили возможность анимировать переходы по страницам</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/724/1*zBwlIi3MKmfnmDCV4S0iXA.gif" /></figure><p>Исходный код можно посмотреть в <a href="https://github.com/Uncleseneca/animated-routes">репозитории</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c492268772e9" width="1" height="1" alt=""><hr><p><a href="https://medium.com/breadhead-stories/%D0%B0%D0%BD%D0%B8%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D1%8B%D0%B5-%D1%80%D0%BE%D1%83%D1%82%D1%8B-%D0%B2-react-c492268772e9">Анимированные роуты в React</a> was originally published in <a href="https://medium.com/breadhead-stories">Breadhead Stories</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Анимированне роуты в React]]></title>
            <link>https://uncleseneca.medium.com/%D0%B0%D0%BD%D0%B8%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%B5-%D1%80%D0%BE%D1%83%D1%82%D1%8B-%D0%B2-react-7e9780d83d16?source=rss-547898b45720------2</link>
            <guid isPermaLink="false">https://medium.com/p/7e9780d83d16</guid>
            <category><![CDATA[animation]]></category>
            <category><![CDATA[react-spring]]></category>
            <category><![CDATA[react-router]]></category>
            <category><![CDATA[react]]></category>
            <dc:creator><![CDATA[Владимир Голотин]]></dc:creator>
            <pubDate>Sat, 15 Jun 2019 22:16:19 GMT</pubDate>
            <atom:updated>2019-06-17T11:12:19.339Z</atom:updated>
            <content:encoded><![CDATA[<h3>Анимированные роуты в React</h3><p>React плохо приспособлен для анимаций компонентов. Без дополнительных ухищрений компонент не будет ждать завершения анимации при удалении из дерева. <br>Как раз это происходит при роутинге — один роут заменяет другой при переходе на страницу.<br>К счастью, существует много библиотек, которые облегчают эту задачу. Одна из них —<a href="https://www.react-spring.io/"> react-spring</a>.</p><p>Для анимации роутов в React нужно знать несколько подводных камней, которые мы сегодня рассмотрим.</p><p>Использовать будем популярный react-router. Создадим компонент, который возвращает Switch и содержит несколько роутов:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WDFQM2EDdREglMmau7DY_A.png" /></figure><p>Теперь добавим обвязку react-spring:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*W11JiH-k_p0IIO8TwMTYlw.png" /></figure><p>Давайте разберемся по порядку:</p><ol><li><strong>useRouter</strong> — хук, который получаем, используя useContext и <strong>__RouterContext</strong> — вспомогательный компонент react-router.</li><li><strong>useTransition</strong> — хук react-spring, который помогает анимировать компоненты, которые удаляются и добавляются</li></ol><p>Первым аргументов в <strong>useTransition</strong> передаем объект <strong>location</strong>, который содержит всю информацию о роутинге. Этот объект мы увидим в рендер методе под именем <strong>item </strong>и передадим его в компонент <strong>Switch. </strong>Это нужно, чтобы <strong>Switch </strong>получал информацию о роутинге не из браузера, а через пропсы. Так мы сможем синхронизировать <strong>react-spring</strong> и <strong>react-router</strong>.</p><p>Вторым аргументом передаем функцию, которая принимает <strong>item (location) </strong>и возвращает <strong>location.key </strong>— уникальный ключ для каждого роута.</p><p>Третьим аргументом передаем параметры анимаций <strong>from, enter и leave</strong></p><p><strong>from</strong> — стили компонента, который добавляется в дерево<br><strong>enter</strong> — стили компонента, который добавился в дерево<br><strong>leave</strong> — стили компонента, который удаляется из дерева</p><p>3. <strong>transitions</strong> — массив объектов, каждый из которых состоит из</p><p><strong>item</strong> — первый аргумент, который мы передавали в <strong>useTransition<br>props (transition)</strong>— стили анимаций<br><strong>key</strong> — то, что вернула функция <strong>location</strong> =&gt; <strong>location.key</strong></p><p>Передаем <strong>key</strong> и <strong>transition</strong> в <strong>animated.div</strong> для улучшенной производительности и передаем item в <strong>Switch</strong>, чтобы синхронизировать <strong>react-router</strong> <strong>react-spring</strong></p><p>В результате мы получили возможность анимировать переходы по страницам</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/724/1*zBwlIi3MKmfnmDCV4S0iXA.gif" /></figure><p>Исходный код можно посмотреть в <a href="https://github.com/Uncleseneca/animated-routes">репозитории</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7e9780d83d16" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Как и почему React  использует связные списки в архитектуре Fiber]]></title>
            <link>https://uncleseneca.medium.com/%D0%BA%D0%B0%D0%BA-%D0%B8-%D0%BF%D0%BE%D1%87%D0%B5%D0%BC%D1%83-react-%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D1%83%D0%B5%D1%82-%D1%81%D0%B2%D1%8F%D0%B7%D0%BD%D1%8B%D0%B5-%D1%81%D0%BF%D0%B8%D1%81%D0%BA%D0%B8-%D0%B2-%D0%B0%D1%80%D1%85%D0%B8%D1%82%D0%B5%D0%BA%D1%82%D1%83%D1%80%D0%B5-fiber-17470edf5d15?source=rss-547898b45720------2</link>
            <guid isPermaLink="false">https://medium.com/p/17470edf5d15</guid>
            <category><![CDATA[react]]></category>
            <category><![CDATA[linked-lists]]></category>
            <dc:creator><![CDATA[Владимир Голотин]]></dc:creator>
            <pubDate>Sun, 31 Mar 2019 20:59:57 GMT</pubDate>
            <atom:updated>2019-03-31T20:59:57.863Z</atom:updated>
            <content:encoded><![CDATA[<h3>Как и почему React использует связные списки в архитектуре Fiber</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/984/1*nEyKDJfa_3x_4nzokKIbZg.png" /><figcaption>Так выглядит рабочий цикл. <a href="https://www.youtube.com/watch?v=ZCuYPiUIONs">Классный доклад Lin Clark</a> на ReactConf 2017</figcaption></figure><p>Это перевод статьи Макса Корецки <a href="https://medium.com/react-in-depth/the-how-and-why-on-reacts-usage-of-linked-list-in-fiber-67f1014d0eb7">The how and why on React’s usage of linked list in Fiber to walk the component’s tree</a></p><p>Я много времени уделяю <a href="https://blog.angularindepth.com/practical-application-of-reverse-engineering-guidelines-and-principles-784c004bb657">реверс-инжинирингу веб-технологий</a> и пишу о своих выводах. В прошлом году я сосредоточился в основном на Angular, в результате чего появилась самая большая публикация об Angular в Интернете — <a href="https://blog.angularindepth.com/">Angular-In-Depth</a>. Пришло время погрузиться в React. <a href="https://medium.freecodecamp.org/what-every-front-end-developer-should-know-about-change-detection-in-angular-and-react-508f83f58c6a">Обнаружение изменений</a> стало моей основной темой в Angular и я надеюсь вскоре достичь этого уровня в React.</p><p>Механизм обнаружения изменений часто называют сверкой или рендерингом, а Fiber — его самой новой реализацией. Благодаря такой архитектуре, он предоставляет возможности для реализации многих интересных функций, таких как неблокирующий рендеринг, применение обновлений в зависимости от приоритета и предварительного рендеринга контента в фоновом режиме. Эти особенности в <a href="https://twitter.com/acdlite/status/1056612147432574976">философии параллельного React</a> называется <strong>тайм-слайсинг</strong> (time-slicing).</p><p>Помимо решения реальных проблем разработчиков приложений, внутренняя реализация этих механизмов очень интересна с инженерной точки зрения. В исходниках полно информации, которая поможет нам расти как разработчикам.</p><p>Если вы загуглите “React Fiber”, то увидите в результатах поиска достаточно много статей. Но все они, за исключением <a href="https://github.com/acdlite/react-fiber-architecture">статьи Andrew Clark</a>, являются достаточно высокоуровневыми объяснениями. В этой статье я буду ссылаться на труд Andrew и подробно объясню некоторые особо важные детали в архитектуре Fiber. После прочтения этой статьи советую посмотреть <a href="https://www.youtube.com/watch?v=ZCuYPiUIONs">прекрасный доклад Lin Clark</a> на ReactConf 2017. Этих материалов больше чем достаточно, чтобы грокнуть новую архитектуру React.</p><h4>Введение</h4><p>Архитектура Fiber состоит из двух основных фаз: сверка/рендер и коммит. В исходном коде фаза сверки в основном называется “фаза рендеринга”. Это фаза, когда React обходит дерево компонентов:</p><ul><li>обновляет стейт и пропсы</li><li>вызывает методы жизненного цикла</li><li>получает дочерние компоненты из родителя</li><li>сравнивает их с предыдущими дочерними компонентами</li><li>определяет необходимые обновления DOM</li></ul><p><strong>Все эти действия называются работой (work) внутри Fiber ноды </strong>. Типы работ, которые необходимо выполнить, зависят от типа React элемента. Например, для классового компонента React должен инстанцировать класс, в то время как для функционального компонента он этого не делает. <a href="https://github.com/facebook/react/blob/340bfd9393e8173adca5380e6587e1ea1a23cefa/packages/shared/ReactWorkTags.js#L29-L28">Здесь</a> вы можете увидеть все типы элементов в React, над которыми может выполняться работа. Про них говорит Andrew:</p><blockquote>При работе с пользовательским интерфейсом проблема заключается в том, что если<strong> слишком много работы выполняется одновременно</strong>, это может привести к потере частоты кадров…</blockquote><p>Что же значит “одновременно”? React обходит все дерево компонентов <strong>синхронно </strong>и выполняет работу для каждого компонента, поэтому вполне вероятно, что он может работать над обновлением компонентов больше доступных 16 мс. А это приведет к видимым задержкам работы интерфейса.</p><p>Как же можно помочь?</p><blockquote>Новые браузеры (и React Native) реализуют API, которые помогают решить эту проблему…</blockquote><p>Новый API является глобальной функцией <a href="https://developers.google.com/web/updates/2015/08/using-requestidlecallback">requestIdleCallback</a>, которая может быть использована для того, чтобы поставить функцию в очередь на вызов во время простоя браузера. Вот как вы могли бы использовать ее сами:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/df99a88cae0d16dc5dcd437c8de4752e/href">https://medium.com/media/df99a88cae0d16dc5dcd437c8de4752e/href</a></iframe><p>Если я открою консоль и запущу код выше, Chrome выведет в консоль 49.9 false. Это говорит о том, что у меня 49,9 мс на выполнение любой работы, и я еще не израсходовал все отведенное мне время, в противном случае deadline.didTimeout будет true. Имейте в виду, что timeRemaining может измениться, как только браузер получит некоторую работу, поэтому его следует постоянно проверять.</p><blockquote>requestIdleCallback на самом деле ограничивает нас чуть больше, чем хотелось бы и выполняется недостаточно часто для производительного рендеринга, поэтому команде React пришлось реализовать свою собственную версию.</blockquote><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7ec8f7d56711bb6ffe41145304276900/href">https://medium.com/media/7ec8f7d56711bb6ffe41145304276900/href</a></iframe><p>Мы выполняем работу над одним компонентом, а затем возвращаем ссылку на следующий компонент для обработки. Это сработало бы, если бы не одна деталь. Невозможно обрабатывать все дерево компонентов синхронно, <a href="https://reactjs.org/docs/codebase-overview.html#stack-reconciler">как в предыдущей реализации алгоритма сверки</a>. И в этом проблема, о которой говорит Andrew:</p><blockquote>Для того чтобы использовать эти API, вам нужен способ разбить рендеринг на части</blockquote><p>Поэтому для решения этой проблемы React пришлось реализовать заново алгоритм обхода дерева <strong>от синхронной рекурсивной модели, которая опиралась на стек вызовов, к асинхронной модели со связанными списком и указателями</strong>. И об этом пишет Andrew:</p><blockquote>Если вы полагаетесь только на [встроенный] стек вызовов, он будет продолжать работать до тех пор, пока стек не станет пустым… Не будет ли здорово, если мы можем прервать стек вызовов по своему усмотрению и манипулировать фреймами стека вручную? Это и есть цель архитектуры React Fiber. Fiber является повторной реализацией стека, написанной для React компонентов. Один Fiber можно представить себе как виртуальный стековый фрейм.</blockquote><h4>Пара слов о стеке вызовов</h4><p>Полагаю, вы все знакомы с понятием стека звонков. Это то, что вы видите в инструментах отладки вашего браузера, если вы ставите код на паузу в точке останова. Вот несколько цитат и диаграмм из <a href="https://www.wikiwand.com/ru/%D0%A1%D1%82%D0%B5%D0%BA_%D0%B2%D1%8B%D0%B7%D0%BE%D0%B2%D0%BE%D0%B2">Википедии</a>:</p><blockquote><strong>Стек вызовов</strong>— в теории вычислительных систем, <a href="https://www.wikiwand.com/ru/%D0%A1%D1%82%D0%B5%D0%BA">LIFO-стек</a>, хранящий информацию для возврата управления из <a href="https://www.wikiwand.com/ru/%D0%9F%D0%BE%D0%B4%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B0">подпрограмм</a> в программу… <strong>Стек вызовов</strong> состоит из <strong>фреймов</strong>…Каждый фрейм соответствует выполняемой подпрограмме, из которой еще не был совершен выход.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/525/1*CYkiyW8NPiQrpEJEwCaMgA.png" /><figcaption>Стек вызовов</figcaption></figure><h4>Почему стек вызовов важен для React?</h4><p>Как мы определили в первой части статьи, React обходит дерево компонентов во время фазы сверки/рендеринга и выполняет работу для компонентов. В предыдущей реализации сверщика (reconciler) использовалась синхронная рекурсивная модель, которая опиралась на встроенный стек вызовов для обхода дерева. Вот как <a href="https://reactjs.org/docs/reconciliation.html#recursing-on-children">документация</a> описывает этот процесс:</p><blockquote>При сравнении двух React DOM-элементов одного типа, React смотрит на атрибуты обоих, сохраняет лежащий в основе этих элементов DOM-узел и обновляет только изменённые атрибуты.</blockquote><p>Если подумать, то каждый рекурсивный вызов добавляет фрейм в стек. И это происходит синхронно. Предположим, у нас есть следующее дерево компонентов:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/484/1*xuJuQxJMdOZrhTMTjZr3ZA.png" /></figure><p>Это дерево состоит из объектов с функцией рендеринга. Вы можете думать о них как о инстансах компонентов:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a778acd00a358f9195f5a3032428d0ce/href">https://medium.com/media/a778acd00a358f9195f5a3032428d0ce/href</a></iframe><p>React должен обходить это дерево и выполнять работу для каждого компонента. Для упрощения представим работу как вывод в консоль названия текущего компонента и получение его дочерних компонентов. Вот как мы это делаем с рекурсией.</p><h4>Рекурсивный обход</h4><p>Основная функция, которая обходит дерево, называется walk в реализации ниже:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/48fac07d712ea4ade45c884df4c725ee/href">https://medium.com/media/48fac07d712ea4ade45c884df4c725ee/href</a></iframe><p>Вот результат, который мы получим:</p><p>a1, b1, b2, c1, d1, d2, b3, c2</p><p>Если вам непонятна рекурсия, посмотрите мою <a href="https://medium.freecodecamp.org/learn-recursion-in-10-minutes-e3262ac08a1">углубленную статью о рекурсии</a>.</p><p>Рекурсивный подход интуитивно понятен и хорошо подходит для обхода деревьев. Но, как мы выяснили, у него есть ограничения. Самое большое, что мы не можем разбить работу на инкрементальные единицы. Мы не можем приостановить работу над конкретным компонентом и возобновить ее позже. При таком подходе React просто продолжает итерацию до тех пор, пока все компоненты не будут обработаны и стек не станет пустым.</p><p>Так как же React реализует алгоритм обхода дерева без рекурсии? Для этого в React используется алгоритм обхода, основанный на связных списках. Это позволяет приостановить обход и остановить рост стека.</p><h4>Обход связного списка</h4><p>Мне повезло, что я нашел <a href="https://github.com/facebook/react/issues/7942#issue-182373497">здесь</a> суть алгоритма, описанного Sebastian Markbåge. Для реализации алгоритма нам нужна структура данных с 3 полями:</p><ul><li>дочерний элемент(child) — ссылка на дочерний элемент</li><li>соседний элемент(sibling) — ссылка на первый соседний элемент</li><li>родительский элемент(return) — ссылка на родительский элемент</li></ul><p>В контексте нового алгоритма сверки в React структура данных с этими полями называется Fiber. Под капотом находится представление React элемента, который содержит очередь работ, которые нужно выполнить. Подробнее об этом я расскажу в следующих статьях.</p><p>На следующей схеме показана иерархия объектов, связанных между собой через связанный список, и типы связей между ними:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/536/1*JEVI0IOk5V0JItVTJoYAnQ.png" /></figure><p>Итак, давайте сначала определим наш пользовательский конструктор нод</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a4debc5c70238d078714899237560df0/href">https://medium.com/media/a4debc5c70238d078714899237560df0/href</a></iframe><p>И функция, которая берет массив нод и связывает их вместе. Мы собираемся использовать его, чтобы связать дочерние элементы, возвращаемых рендер методом:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1356558e6792e292be413726198e12e2/href">https://medium.com/media/1356558e6792e292be413726198e12e2/href</a></iframe><p>Функция выполняет итерацию по массиву нод, начиная с последней и связывает их в единый список. Она возвращает ссылку на первый элемент в списке. Вот как это работает:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d3090823ed2dc4525e56031c48cc1c54/href">https://medium.com/media/d3090823ed2dc4525e56031c48cc1c54/href</a></iframe><p>Также мы реализуем вспомогательную функцию, которая выполняет некоторую работу для ноды. В нашем случае, она будет выводить в консоль имя компонента. Но кроме того, он также извлекает дочерние элементы из компонента и связывает их вместе:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b6898cabc6d3d6e362480311526ea136/href">https://medium.com/media/b6898cabc6d3d6e362480311526ea136/href</a></iframe><p>Итак, теперь мы готовы к реализации алгоритма обхода. Это parent first, depth-first реализация. Вот код с комментариями:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2f01dce25780c8aaecd8a01b077a812c/href">https://medium.com/media/2f01dce25780c8aaecd8a01b077a812c/href</a></iframe><p>Хотя реализация не очень сложна для понимания, вам может понадобиться некоторое время,чтобы грокнуть ее. <a href="https://stackblitz.com/edit/js-tle1wr">Здесь</a> есть удобная песочница с этим алгоритмом. Идея заключается в том, чтобы сохранить ссылку на текущий узел и переназначить его при спуске по дереву, пока мы не достигнем конца ветви. Затем мы используем указатель на родительский элемент для возврата к общему родителю.</p><p>Если мы теперь проверим стек вызовов с помощью этой реализации, то вот что мы увидим:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/436/1*f9KqyL_0Kc17x2H05dfWPw.gif" /></figure><p>Как видите, стек не растет, когда мы спускаемся по дереву. Но если теперь поставить дебаггер в функцию doWork и записать имена нод в журнал, то увидим следующее:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/320/1*TwCyMHCb8MeuNg-JOnYEww.gif" /></figure><p><strong>Похоже на стек вызовов в браузере</strong>. Таким образом, с помощью этого алгоритма мы эффективно заменяем реализацию стека вызовов в браузере на нашу собственную реализацию. Вот что Andrew описывает здесь:</p><blockquote>Fiber является повторной реализацией стека, написанной для React компонентов. Один fiber можно представить себе как виртуальный фрейм стека.</blockquote><p>Поскольку мы теперь контролируем стек, сохраняя ссылку на ноду, которая служит верхним фреймом:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1ae390cd35ab7351947ce180d42f1d3f/href">https://medium.com/media/1ae390cd35ab7351947ce180d42f1d3f/href</a></iframe><p>мы можем остановить обход в любое время и вернуться к нему позже. Именно этого мы и хотели добиться, чтобы иметь возможность использовать новый API requestIdleCallback.</p><h4>Рабочий цикл в React</h4><p><a href="https://github.com/facebook/react/blob/95a313ec0b957f71798a69d8e83408f40e76765b/packages/react-reconciler/src/ReactFiberScheduler.js#L1118">Вот</a> код, который реализует рабочий цикл в React</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0da0804ca4509857bcf09a8301fcd44f/href">https://medium.com/media/0da0804ca4509857bcf09a8301fcd44f/href</a></iframe><p>Как видите, он отлично соотносится с алгоритмом, который я представил выше. Он сохраняет ссылку на текущую fiber ноду в переменной nextUnitOfWork, которая действует как верхний фрейм.</p><p>Алгоритм может ходить по дереву компонентов <strong>синхронно</strong> и выполнять работу для каждой fiber ноды в дереве (nextUnitOfWork). Обычно это касается так называемых интерактивных обновлений, вызываемых событиями пользовательского интерфейса (клик мышью, ввод и т.д.). Или может пройтись по дереву компонентов <strong>асинхронно</strong>, проверяя, осталось ли время после выполнения работы для fiber ноды. Функция shouldYield возвращает результат на основе переменных <a href="https://github.com/facebook/react/blob/95a313ec0b957f71798a69d8e83408f40e76765b/packages/react-reconciler/src/ReactFiberScheduler.js#L1806">deadlineDidExpire</a> и <a href="https://github.com/facebook/react/blob/95a313ec0b957f71798a69d8e83408f40e76765b/packages/react-reconciler/src/ReactFiberScheduler.js#L1809">deadline</a>, которые постоянно обновляются по мере выполнения React работы для fiber ноды.</p><p>Функция peformUnitOfWork подробно описана <a href="https://medium.com/react-in-depth/inside-fiber-in-depth-overview-of-the-new-reconciliation-algorithm-in-react-e1c04700ef6e#1a7d">здесь</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=17470edf5d15" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Нормализация UNICODE строк в Javascript]]></title>
            <link>https://uncleseneca.medium.com/%D0%BD%D0%BE%D1%80%D0%BC%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F-unicode-%D1%81%D1%82%D1%80%D0%BE%D0%BA-%D0%B2-javascript-88cbbf50348d?source=rss-547898b45720------2</link>
            <guid isPermaLink="false">https://medium.com/p/88cbbf50348d</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[normalization]]></category>
            <category><![CDATA[unicode]]></category>
            <dc:creator><![CDATA[Владимир Голотин]]></dc:creator>
            <pubDate>Mon, 25 Mar 2019 12:44:47 GMT</pubDate>
            <atom:updated>2019-03-25T14:40:26.983Z</atom:updated>
            <content:encoded><![CDATA[<p>При обработке пользовательского ввода часто приходится сравнивать его значение с референсом. При наивном сравнении легко допустить ошибку из-за возможности модификации символов в UNICODE.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/378/1*ECHMvuQXpYxWoHMPaGfFmA.png" /></figure><p>В типографике используются <a href="https://www.wikiwand.com/ru/%D0%94%D0%B8%D0%B0%D0%BA%D1%80%D0%B8%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B5_%D0%B7%D0%BD%D0%B0%D0%BA%D0%B8">диакритические знаки</a> для модификации символов.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/794/1*MeT099Pibq3FSi_fc0sRqQ.png" /><figcaption>Модификация кириллической у</figcaption></figure><p>Для реализации таких изменений в UNICODE предоставили возможность <a href="https://www.wikiwand.com/en/Combining_character">композиции символов</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/706/1*iGej0hbiMX780Ot6mdNp8w.png" /><figcaption>Композитный и простой символы</figcaption></figure><p>Сравнение таких символов через === в Javascript даст false, поэтому для облегчения жизни существует метод <a href="https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/String/normalize">String.prototype.normalize()</a>, который возвращает нормализованную строку.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/652/1*Hd3RYLvBHGcbVzD6SgfAGg.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=88cbbf50348d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Подробный обзор React Fiber]]></title>
            <link>https://uncleseneca.medium.com/%D0%BF%D0%BE%D0%B4%D1%80%D0%BE%D0%B1%D0%BD%D1%8B%D0%B9-%D0%BE%D0%B1%D0%B7%D0%BE%D1%80-react-fiber-66485d12bd37?source=rss-547898b45720------2</link>
            <guid isPermaLink="false">https://medium.com/p/66485d12bd37</guid>
            <category><![CDATA[fiber]]></category>
            <category><![CDATA[react]]></category>
            <dc:creator><![CDATA[Владимир Голотин]]></dc:creator>
            <pubDate>Tue, 19 Mar 2019 11:32:32 GMT</pubDate>
            <atom:updated>2021-01-29T11:49:51.926Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/691/1*gwgSW5BCe6W0mhtN20bErw.png" /></figure><p>Это перевод статьи <a href="https://medium.com/@maxim.koretskyi">Макса Корецки</a> <a href="https://medium.com/react-in-depth/inside-fiber-in-depth-overview-of-the-new-reconciliation-algorithm-in-react-e1c04700ef6e">Inside Fiber: in-depth overview of the new reconciliation algorithm in React</a>.</p><p>React — это JavaScript-библиотека для создания пользовательских интерфейсов. В ее основе лежит механизм, который отслеживает изменения стейта и отображает обновленный стейт на экране. В действительности, мы знаем этот процесс как <strong>сверку</strong> (reconciliation). Мы вызываем метод setState, и фреймворк проверяет, изменились ли стейт или пропсы, и ререндерит компонент.</p><p>Документация React предоставляют <a href="https://reactjs.org/docs/reconciliation.html">хороший обзор</a> механизма сверки на высоком уровне: роль элементов React, методы жизненного цикла и метод render, а также дифференцирующий алгоритм, применяемый к дочерним компонентам. Дерево иммутабельных элементов React, возвращаемое из метода render, обычно называется “виртуальным DOM” (virtual DOM). Этот термин помог объяснить React людям на ранней стадии, но он также вызвал недопонимание и больше не используется в документации React. В этой статье я буду называть его деревом элементов React.</p><p>Кроме дерева элементов React, во фреймворке всегда было дерево внутренних элементов (компоненты, DOM ноды и т.д.), используемых для хранения стейта. Начиная с версии 16, React выпустил новую реализацию этого дерева внутренних элементов и алгоритма под названием Fiber, который управляет им. Чтобы узнать о преимуществах архитектуры Fiber, ознакомьтесь со статьей <a href="https://medium.com/dailyjs/the-how-and-why-on-reacts-usage-of-linked-list-in-fiber-67f1014d0eb7">The How and why on React’s use of connected list in Fiber</a>.</p><p>Это первая статья из серии, цель которой — научить вас внутренней архитектуре React. В этой статье я хочу дать подробный обзор важных концепций и структур данных, имеющих отношение к алгоритму. Как только у нас будет достаточно информации, мы исследуем алгоритм и основные функции, используемые для обхода и обработки дерева Fiber. В следующих частях цикла я покажу, как React использует алгоритм для выполнения первого рендеринга и обновления стейта и пропсов. Оттуда мы перейдем к деталям реализации планировщика (scheduler), процесса сверки дочерних компонентов и механизма построения списка эффектов.</p><p>Это довольно продвинутый материал. Я рекомендую вам прочитать эту статью, чтобы понять магию, лежащую в основе внутренней работы React. Эта серия статей также послужит вам отличным руководством, если вы планируете начать вносить свой вклад в React. Я часто использую реверс-инжиниринг, поэтому здесь будет много ссылок на источники из последней версии 16.6.0.</p><p>Обратите внимание, что вам не нужно знать ничего из этого, чтобы использовать React. Эта статья о том, как работает React внутри.</p><h4>Настройка</h4><p>Вот простое приложение, которое я буду использовать в этой серии статей. У нас есть кнопка, которая просто увеличивает отображаемое на экране число:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/210/1*PqF2Y1pkX8isKKIrWgrRSA.gif" /></figure><p>И вот реализация:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6b5f8c2f0462ed32c3d40a95df2b58f2/href">https://medium.com/media/6b5f8c2f0462ed32c3d40a95df2b58f2/href</a></iframe><p>Пример доступен <a href="https://stackblitz.com/edit/react-t4rdmh">здесь</a>. Это простой компонент, который возвращает два дочерних элемента button и span из метода render. Как только вы нажимаете на кнопку, стейт компонента обновляется внутри обработчика. Это приводит к обновлению текста в элементе span.</p><p>Во время сверки React выполняет много работы. Например, вот список высокоуровневых операций, выполняемых во время первого рендера и после обновления состояния в нашем простом приложении:</p><ul><li>обновить пропс count в стейте ClickCounter</li><li>получить дочерние компоненты ClickCounter и сравнить их пропсы</li><li>обновить пропсы для span элемента</li></ul><p>В процессе сверки выполняются и другие действия, такие как вызов методов жизненного цикла или обновление ссылок. Все эти действия в Fiber архитектуре в совокупности называются “работой” (work). Тип работы обычно зависит от типа React элемента. Например, для классового компонента React должен создать инстанс, в то время как для функционального компонента этого делать не нужно. В React есть много типов элементов, например, классовые и функциональные компоненты, хост-компоненты (DOM-ноды), порталы и т.д. Тип элемента React определяется первым параметром функции createElement. Эта функция обычно используется в методе renderдля создания элемента.</p><p>Прежде чем мы приступим к исследованию алгоритма работы Fiber, давайте сначала познакомимся со структурами данных, используемыми React.</p><h4>От React элементов к Fiber нодам</h4><p>Каждый компонент React имеет UI-представление, которое мы можем назвать шаблоном, который возвращается из метода render. Вот шаблон для нашего компонента ClickCounter:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4dfd8e6a44e2bd21cc94d453c93d9960/href">https://medium.com/media/4dfd8e6a44e2bd21cc94d453c93d9960/href</a></iframe><p><strong>React элементы</strong></p><p>Как только шаблон проходит через компилятор JSX, вы получаете в итоге кучу React элементов. Это то, что на самом деле возвращается из метода render компонентов React, а не HTML. Поскольку нам не нужно использовать JSX, метод render для нашего компонента ClickCounter можно переписать следующим образом:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9d5173e5380a6013439e014174ad9fa9/href">https://medium.com/media/9d5173e5380a6013439e014174ad9fa9/href</a></iframe><p>Вызовы метода React.createElement в методе render создадут две структуры данных, как указано ниже:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b83d058e55b1c08e33dd1edb80da9eae/href">https://medium.com/media/b83d058e55b1c08e33dd1edb80da9eae/href</a></iframe><p>Вы видите, что React добавляет свойство <a href="https://overreacted.io/why-do-react-elements-have-typeof-property/">$$typeof</a> к этим объектам, чтобы однозначно идентифицировать их как элементы React. Затем мы видим свойства type, key и props, которые описывают элемент. Значения берутся из того, что вы передаете в функцию React.createElement. Обратите внимание, что React представляет текстовое содержимое елемента как свойство children. Также обработчик кликов является частью пропсов элемента button. Есть и другие поля на React элементах, такие как ref, которые выходят за рамки этой статьи.</p><p>React элемент ClickCounter не имеет пропсов и key</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/08702dad70567cb83b6595ecaf33481b/href">https://medium.com/media/08702dad70567cb83b6595ecaf33481b/href</a></iframe><h4>Fiber ноды</h4><p>При сверке данные от каждого React элемента, возвращаемые методом render, сливаются в дерево fiber нод. Каждый React элемент имеет соответствующую fiber ноду . В отличие от элементов React, fiber-ноды не создаются заново при каждом рендеринге. Это мутабельные структуры данных, содержащие состояние компонентов и DOM.</p><p>Ранее мы обсуждали, что в зависимости от типа React элемента фреймворк должен выполнять различные виды задач. В нашем примере, для компонентов класса ClickCounter он вызывает методы жизненного цикла и метод render, в то время как для хост-компонента (DOM ноды) он выполняет мутацию DOM. Таким образом, каждый элемент React преобразуется в fiber ноду <a href="https://github.com/facebook/react/blob/769b1f270e1251d9dbdce0fcbd9e92e502d059b8/packages/shared/ReactWorkTags.js">соответствующего типа</a>, которая описывает задачи, которые необходимо выполнить.</p><p><strong>Вы можете думать о fiber ноде как о структуре данных, которая представляет собой некоторую работу, или, другими словами, единицу работы. Архитектура fiber также обеспечивает удобный способ отслеживания, планирования, приостановки и прерывания работы.</strong></p><p>Когда React элемент впервые преобразуется в fiber ноду, React использует данные этого элемента для создания fiber в функции <a href="https://github.com/facebook/react/blob/769b1f270e1251d9dbdce0fcbd9e92e502d059b8/packages/react-reconciler/src/ReactFiber.js#L414">createFiberFromTypeAndProps</a>. В последующих обновлениях React повторно использует fiber ноды и просто обновляет необходимые свойства, используя данные от соответствующего элемента React. Также может понадобиться переместить ноду в иерархии на основе пропса key или удалить его, если соответствующий элемент React больше не возвращается из метода render.</p><blockquote>Взгляните на функцию <a href="https://github.com/facebook/react/blob/95a313ec0b957f71798a69d8e83408f40e76765b/packages/react-reconciler/src/ReactChildFiber.js#L239"><strong>ChildReconciler</strong></a>, чтобы увидеть список всех действий и соответствующих функций, выполняемых React для существующих fiber нод.</blockquote><p>Поскольку React создает fiber ноду для каждого React элемента и поскольку у нас есть дерево этих элементов, у нас будет дерево fiber нод. В случае с нашим приложением это выглядит так:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/555/1*OOiYAxFRNjaWMQNiO2hAcg.png" /></figure><p>Все fiber ноды соединяются через связанный список, используя следующие свойства: дочерние, child, sibling и return. Для более подробной информации о том, почему это работает таким образом, смотрите мою статью <a href="https://medium.com/dailyjs/the-how-and-why-on-reacts-usage-of-linked-list-in-fiber-67f1014d0eb7">The how and why on React’s use of links list in Fiber</a>, если вы еще не читали ее.</p><h4>Current и WorkInProgress деревья fiber нод</h4><p>После первого рендеринга React получает дерево fiber нод, которое отражает состояние приложения, использовавшегося для рендеринга. Это дерево часто называют current. Когда React начинает работать над обновлениями, он строит так называемое дерево WorkInProgress, которое отражает будущее состояние, которое будет выводиться на экран.</p><p>Все работы выполняются на нодах из дерева WorkInProgress. Когда React проходит через current дерево, для каждой существующей ноды он создает альтернативную, которая составляет дерево WorkInProgress. Эта нода создается с использованием данных из React элементов, возвращаемых render методом. Как только обновления будут обработаны и все связанные с ними работы будут завершены, React будет иметь альтернативное дерево, готовое к отображению на экране. Как только дерево WorkInProgress отображается на экране, оно становится current деревом.</p><p>Одним из ключевых принципов React является последовательность. React всегда обновляет DOM за один проход — он не показывает частичных результатов. Дерево WorkInProgress служит для пользователя “черновиком”, так что сначала React может обрабатывать все компоненты, а затем показывать их изменения на экране.</p><p>В исходном коде вы увидите множество функций, которые используют fiber ноды как из current дерева, так и из дерева WorkInProgress. Вот одна из таких функций:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d10b9f25439d1222bd68f0c016d242d3/href">https://medium.com/media/d10b9f25439d1222bd68f0c016d242d3/href</a></iframe><p>Каждая fiber нода содержит ссылку на свой аналог из другого дерева в поле alternate. Нода из current дерева указывает на ноду из дерева WorkInProgress и наоборот.</p><h4>Побочные эффекты</h4><p>React компонент можно представить как функцию, использующую стейт и пропсы для вычисления представления. Любое другое действие, такое как мутация DOM или вызов методов жизненного цикла, следует рассматривать как побочный эффект или, попросту говоря, эффект. Эффекты также упоминаются в <a href="https://reactjs.org/docs/hooks-overview.html#%EF%B8%8F-effect-hook">документации</a>:</p><blockquote>Скорее всего, вы ранее выполняли загрузку данных, подписку или измение DOM-элементов вручную из React. Мы называем эти операции “побочными эффектами” (или “эффектами” для краткости), потому что они могут повлиять на другие компоненты и не могут быть выполнены во время рендеринга.</blockquote><p>Вы можете увидеть, как большинство обновлений стейта и пропсов приводят к побочным эффектам. А поскольку применение эффектов — это разновидность работы, fiber нода является удобным механизмом для отслеживания эффектов в дополнение к обновлениям. Каждая fiber нода может иметь эффекты, связанные с ним. Они содержатся в поле effectTag.</p><p>Таким образом, эффекты в Fiber в основном определяют <a href="https://github.com/facebook/react/blob/b87aabdfe1b7461e7331abb3601d9e6bb27544bc/packages/shared/ReactSideEffectTags.js">работу</a>, которая должна быть проделана для инстансов после обработки обновлений. Для хост-компонентов (DOM) работа состоит из добавления, обновления или удаления элементов. Для классовых компонентов может потребоваться обновление рефов и вызов методов жизненного цикла componentDidMount и componentDidUpdate. Существуют и другие эффекты, соответствующие другим типам fiber нод.</p><h4>Список эффектов</h4><p>React реагирует на обновления процессов очень быстро и для достижения такого уровня производительности использует несколько интересных методик. Одним из них является построение связного списка fiber нод с эффектами для быстрой итерации. Итерация связного списка происходит намного быстрее, чем дерево, и нет необходимости тратить время на ноды без побочных эффектов.</p><p>Целью этого списка является помечать ноды, которые имеют обновления DOM или другие эффекты, связанные с ними. Этот список является подмножеством дерева finishedWork и связан с помощью свойства nextEfect вместо свойства child, используемого в current дереве и дереве WorkInProgress.</p><p><a href="https://medium.com/@dan_abramov">Дэн Абрамов</a> предложил аналогию для списка эффектов. Он предлагает думать о ней как о елке, с “рождественскими гирляндами”, связывающими все эффектные узлы вместе. Чтобы визуализировать это, давайте представим себе следующее дерево fiber нод, где выделенные узлы имеют некоторую работу. Например, наше обновление привело к тому, что c2 был вставлен в DOM, d2 и c1 должны изменить аттрибуты, а b2 нужно запустить метод жизненного цикла. Список эффектов свяжет их вместе, чтобы React мог пропустить другие ноды позже:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/475/1*xdZnpyis_zTRSwQYkd0tcw.png" /></figure><p>Вы можете увидеть, как ноды с эффектами связаны между собой. При переборе нод React использует указатель firstEffect, чтобы определить, откуда начинается список. Таким образом, диаграмма выше может быть представлена в виде связного списка вроде этого:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/712/1*zvFYcc4lw8RR_0_3Yz7UKg.png" /></figure><p>Как видите, React действует в порядке от детей и до родителей.</p><h4>Корневая нода fiber дерева</h4><p>Каждое React приложение содержит один или несколько DOM элементов, которые действуют как контейнеры. В нашем случае это div элемент с ID container.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9a5218e67e51b10b6378eda1a3969ded/href">https://medium.com/media/9a5218e67e51b10b6378eda1a3969ded/href</a></iframe><p>React создает<a href="https://github.com/facebook/react/blob/0dc0ddc1ef5f90fe48b58f1a1ba753757961fc74/packages/react-reconciler/src/ReactFiberRoot.js#L31"> корневую fiber ноду</a> для каждого из этих контейнеров. Вы можете получить к ней доступ, используя ссылку на DOM элемент:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ca3e43eaf99734853f0f351a6cdaf2da/href">https://medium.com/media/ca3e43eaf99734853f0f351a6cdaf2da/href</a></iframe><p>Эта корневая fiber нода хранит ссылку на fiber дерево. Она хранится в current свойстве fiber ноды:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b8a8a4db24b25b33dbbdaca0e7ff4a2d/href">https://medium.com/media/b8a8a4db24b25b33dbbdaca0e7ff4a2d/href</a></iframe><p>Дерево fiber нод начинается со специального типа ноды, которым является HostRoot. Он создан внутри и выступает в качестве родительского компонента для вашего самого верхнего компонента. Есть связь между узлом HostRoot и FiberRoot через свойство StateNode:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c8d5c228b77595a782fd36500651de2a/href">https://medium.com/media/c8d5c228b77595a782fd36500651de2a/href</a></iframe><p>Вы можете изучить fiber дерево, получив доступ к самой верхней ноде HostRoot через корневую fiber ноду. Или вы можете получить отдельную fiber ноду из такого инстанса компонента, как этот:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/523f9466e18c99575ec159a589bfa1cb/href">https://medium.com/media/523f9466e18c99575ec159a589bfa1cb/href</a></iframe><h4>Структура fiber ноды</h4><p>Теперь давайте рассмотрим структуру fiber нод, созданных для компонента ClickCounter.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2c0ce4f3a04aa4d6464e3ae8e8323b72/href">https://medium.com/media/2c0ce4f3a04aa4d6464e3ae8e8323b72/href</a></iframe><p>и <strong>span</strong> DOM элемента:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d4103011710d5b58db0a53833b5b721f/href">https://medium.com/media/d4103011710d5b58db0a53833b5b721f/href</a></iframe><p>У fiber нод достаточно много полей. Назначение полей <strong>alternate</strong>, <strong>effectTag </strong>и<strong>nextEffect</strong> я описал в предыдущих разделах. Теперь давайте посмотрим, зачем нам нужны другие.</p><p><strong>stateNode</strong><br>Содержит ссылку на инстанс класса компонента, DOM ноды или другого типа элемента React, связанного с fiber нодой. В общем, можно сказать, что это свойство используется для хранения локального состояния, связанного с fiber нодой.</p><p><strong>type</strong><br>Определяет функцию или класс, связанный с этой fiber нодой. Для классовых компонентов он указывает на конструктор, а для DOM элементов указывает HTML-тег. Я довольно часто использую это поле, чтобы понять, с каким элементом связана fiber нода.</p><p><strong>tag</strong><br>Определяет <a href="https://github.com/facebook/react/blob/769b1f270e1251d9dbdce0fcbd9e92e502d059b8/packages/shared/ReactWorkTags.js">тип fiber ноды</a>. Используется в алгоритме сверки для определения того, какие работы необходимо выполнить. Как упоминалось ранее, работа варьируется в зависимости от типа React элемента. Функция <a href="https://github.com/facebook/react/blob/769b1f270e1251d9dbdce0fcbd9e92e502d059b8/packages/react-reconciler/src/ReactFiber.js#L414">createFiberFromTypeAndProps</a> сопоставляет React элемент с соответствующим типом fiber ноды. В нашем приложении свойство tag для ClickCountercomponent равно 1, что обозначает ClassComponent, а для span-элемента — 5, что означает HostComponent.</p><p><strong>updateQueue</strong><br>Очередь обновлений стейта, коллбеков и обновлений DOM.</p><p><strong>memoizedState</strong><br>Состояние fiber ноды, которое использовалось для вывода на экран. При обработке обновлений отображается текущее состояние, отображаемое на экране.</p><p><strong>memoizedProps</strong><br>Пропсы fiber ноды, которые были использованы для вывода во время предыдущего рендера.</p><p><strong>pendingProps</strong><br>Пропсы, которые были обновлены на основе новых данных в React элементах и должны быть применены к дочерним компонентам или DOM элементам.</p><p><strong>key</strong><br>Уникальный идентификатор группы дочерних элементов, чтобы помочь React выяснить, какие элементы были изменены, добавлены или удалены из списка. Это связано с описанной здесь функциональностью “списков и ключей” React.<br>Полную структуру fiber ноды можно найти <a href="https://reactjs.org/docs/lists-and-keys.html#keys">здесь</a>.</p><p>Я опустил несколько полей в объяснении выше. В частности, я пропустил указатели child, sibling и return, которые составляют структуру данных дерева, описанную в <a href="https://medium.com/dailyjs/the-how-and-why-on-reacts-usage-of-linked-list-in-fiber-67f1014d0eb7">предыдущей статье</a>. И категория полей типа <strong>expirationTime</strong>, <strong>childExpirationTime </strong>и<strong>mode </strong>которые специфичны для <strong>Scheduler</strong></p><h3>Общий алгоритм</h3><p>React выполняет работу в два основных этапа: <strong>render </strong>и <strong>commit</strong>.</p><p>Во время первого рендера React применяет обновления к компонентам, запланированным через setState или React.render и выясняет, что необходимо обновить в пользовательском интерфейсе. Если это первый рендер, React создает новую fiber ноду для каждого элемента, возвращаемого из рендер метода. В следующих обновлениях fiber ноды для существующих элементов React используются повторно и обновляются. <strong>Результатом фазы является дерево fiber нод, отмеченных побочными эффектами</strong>. Эффекты описывают работу, которая должна быть выполнена в следующей commit фазе. Во время этой фазы React принимает дерево fiber нод, помеченное эффектами, и применяет его к инстансам. Он просматривает список эффектов и выполняет обновления DOM и другие изменения, видимые пользователю.</p><p>Важно понимать, что работа во время первого рендера может выполняться асинхронно. React может обработать один или несколько fiber нод в зависимости от доступного времени, затем остановиться, чтобы спрятать выполненную работу и уступить какому-то событию. Затем он продолжает с того места, на котором остановился. Иногда, однако, может потребоваться отказаться от проделанной работы и начать все сначала. Эти паузы стали возможны благодаря тому, что работа, выполненная на этом этапе, не приводит к каким-либо видимым изменениям для пользователя, таким как обновление DOM.<strong> Напротив, следующая </strong><strong>commit фаза всегда синхроннна</strong>. Это связано с тем, что работа, выполняемая на этом этапе, приводит к изменениям, видимым пользователю, например, обновления DOM. Вот почему React должен сделать это за один проход.</p><p>Вызов методов жизненного цикла является одним из видов работ, выполняемых React. Некоторые методы вызываются во время renderфазы другие — во время commit фазы . Вот список жизненных циклов, вызываемых во время первой render фазы:</p><ul><li>[UNSAFE_]componentWillMount (устарел)</li><li>[UNSAFE_]componentWillReceiveProps (устарел)</li><li>getDerivedStateFromProps</li><li>shouldComponentUpdate</li><li>[UNSAFE_]componentWillUpdate (устарел)</li><li>render</li></ul><p>Как вы видите, некоторые старые методы жизненного цикла, которые выполняются в фазе render, отмечены как UNSAFE начиная с версии 16.3. В настоящее время их в документации называют легаси жизненными циклами. Они будут удалены в будущих релизах 16.x, а их аналоги без префикса UNSAFE будут удалены в 17.0. Подробнее об этих изменениях и предлагаемом пути миграции можно прочитать <a href="https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html">здесь</a>.</p><p>Вам интересно, по какой причине это произошло?</p><p>Мы только что узнали, что поскольку render фаза не производит побочных эффектов, таких как обновления DOM, React может обрабатывать обновления асинхронно (потенциально даже делая это в нескольких потоках). Однако жизненный цикл, помеченный UNSAFE, часто неправильно понимается и используется не по назначению. Разработчики склонны помещать код с побочными эффектами внутри этих методов, что может вызвать проблемы с новым подходом асинхронного рендеринга. Хотя будут удалены только их коллеги без префикса UNSAFE, они все равно могут вызвать проблемы в предстоящем параллельном режиме (от которого вы можете отказаться).</p><p>Ниже приведен список методов жизненного цикла, выполняемых на второй commit фазе:</p><ul><li>getSnapshotBeforeUpdate</li><li>componentDidMount</li><li>componentDidUpdate</li><li>componentWillUnmount</li></ul><p>Поскольку эти методы выполняются в синхронной commit фазе , они могут содержать побочные эффекты и изменять DOM.</p><p>Итак, теперь у нас есть знания, чтобы взглянуть на обобщенный алгоритм, используемый для обхода дерева и выполнения работы.</p><h3>Render фаза</h3><p>Алгоритм сверки всегда начинается с самой верхней fiber ноды HostRoot с помощью функции renderRoot. Однако, React пропускает уже обработанные fiber ноды, пока не обнаруживает ноду с незавершенной работой. Например, если вы вызываете setState глубоко в дереве компонентов, React будет начинаться сверху, но быстро пропускать родителей, пока не доберется до компонента, для которого был вызван метод setState.</p><h4>Основные части рабочего цикла</h4><p>Все fiber ноды обрабатываются в <a href="https://github.com/facebook/react/blob/f765f022534958bcf49120bf23bc1aa665e8f651/packages/react-reconciler/src/ReactFiberScheduler.js#L1136">рабочем цикле</a>. Ниже приведена реализация синхронной части цикла:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/951e6380607f99521da182a5b9276f7a/href">https://medium.com/media/951e6380607f99521da182a5b9276f7a/href</a></iframe><p>В приведенном выше коде, nextUnitOfWork содержит ссылку на fiber ноду из дерева workInProgress, у которого осталась незавершенная работа. Когда React обходит дерево fiber нод, он использует эту переменную, чтобы узнать, есть ли еще fiber нода с незавершенной работой. После обработки текущей fiber ноды переменная будет либо содержать ссылку на следующую ноду в дереве, либо содержать null. В этом случае React выходит из рабочего цикла и готов коммитить изменения.</p><p>Существует 4 основные функции, которые используются для перемещения по дереву и инициирования или завершения работы:</p><ul><li><a href="https://github.com/facebook/react/blob/95a313ec0b957f71798a69d8e83408f40e76765b/packages/react-reconciler/src/ReactFiberScheduler.js#L1056">performUnitOfWork</a></li><li><a href="https://github.com/facebook/react/blob/cbbc2b6c4d0d8519145560bd8183ecde55168b12/packages/react-reconciler/src/ReactFiberBeginWork.js#L1489">beginWork</a></li><li><a href="https://github.com/facebook/react/blob/95a313ec0b957f71798a69d8e83408f40e76765b/packages/react-reconciler/src/ReactFiberScheduler.js#L879">completeUnitOfWork</a></li><li><a href="https://github.com/facebook/react/blob/cbbc2b6c4d0d8519145560bd8183ecde55168b12/packages/react-reconciler/src/ReactFiberCompleteWork.js#L532">completeWork</a></li></ul><p>Чтобы продемонстрировать, как они используются, посмотрите на следующую анимацию обхода через дерево fiber нод. Я использовал упрощенную реализацию этих функций для демонстрации. Каждая функция принимает fiber ноду для обработки, и по мере того, как React спускается вниз по дереву, вы можете увидеть изменения активной в настоящее время fiber ноды. Вы можете четко видеть, как алгоритм переходит от одной ветви к другой. Сначала она завершает работу для детей, а затем переходит к родителям.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/780/1*A3-yF-3Xf47nPamFpRm64w.gif" /></figure><blockquote>Обратите внимание, что прямые вертикальные соединения обозначают соседние элементы, в то время как изогнутые соединения обозначают дочерние элементы, например, <em>b1</em> не имеет дочерних элементов, а b2 имеет один — c1.</blockquote><p><a href="https://vimeo.com/302222454">Вот ссылка на видео</a>, где можно приостановить воспроизведение и просмотреть текущую ноду и состояние функций. Концептуально, вы можете думать, что “begin” — это “шаг в” компонент, а “complete” — это “выйти” из него.</p><p>Начнем с первых двух функций performUnitOfWork и beginWork:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/22eba7c7a789a7a98682d6ecf28da1a9/href">https://medium.com/media/22eba7c7a789a7a98682d6ecf28da1a9/href</a></iframe><p>Функция performUnitOfWork, получает fiber ноду из дерева workInProgress и запускает работу, вызывая функцию beginWork. Эта функция запустит все действия, которые необходимо выполнить для fiber ноды. Для целей этой демонстрации мы просто записываем название ноды, чтобы указать, что работа была выполнена. <strong>Функция </strong><strong>beginWork всегда возвращает указатель на следующую fiber ноду или </strong><strong>null</strong>.</p><p>Если есть следующий дочерний элемент, то он будет присвоен переменной nextUnitOfWork в функции workLoop. Однако, если дочернего элемента нет, React знает, что он достиг конца ветки и может завершить работу над текущим элементом. <strong>После того, как работа будет завершена, ему нужно будет выполнить работу для соседних элементов и вернуться к родителям после этого.</strong> Это делается в полной completeUnitOfWork:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3d52fa9e0ccab075c155415222cc7679/href">https://medium.com/media/3d52fa9e0ccab075c155415222cc7679/href</a></iframe><p>Вы видите, что по сути, это большой while цикл. React выполняет эту функцию, когда нода workInProgress не имеет дочерних элементов. После завершения работы над текущим элементом, он проверяет, есть ли у него соседний. Если есть, то React выходит из функции и возвращает указатель на соседний элемент. Он будет присвоен следующей nextUnitOfWork и React будет выполнять работу для этой ветви, начиная с соседнего элемента. Важно понимать, что на данный момент React завершил работу только для предыдущих соседних элементов, но не завершил работу для родительского. <strong>Только после того, как работа над всеми ветвями, начиная с дочерних, будет завершена, он завершит работу для родительского элемента.</strong></p><p>Как видно из реализации, и performUnitOfWork, и completeUnitOfWork используются в основном для итераций, в то время как основные действия выполняются в функциях beginWork и completeWork. В следующих статьях мы узнаем, что происходит с компонентом ClickCounter и span элементом, когда React начинает выполнять функцииbeginWork иcompleteWork.</p><h4>Commit фаза</h4><p>Фаза начинается с функции <a href="https://github.com/facebook/react/blob/95a313ec0b957f71798a69d8e83408f40e76765b/packages/react-reconciler/src/ReactFiberScheduler.js#L2306">completeRoot</a>. Здесь React обновляет DOM и вызывает методы жизненного цикла до и после мутации.</p><p>Когда React дойдет до этой фазы, у него будет 2 дерева и список эффектов. Первое дерево представляет состояние, отображаемое на экране в данный момент. Затем есть альтернативное дерево, построенное во время render фазы. Они называется finishedWork или workInProgress в исходниках и представляют состояние, которое должно быть отражено на экране. Это альтернативное дерево также связано с текущим деревом через указатели child и sibling.</p><p>Далее, есть список эффектов — подмножество элементов из finishedWork дерева, соединенных указателем nextEffect. Помните, что список эффектов является результатом выполнения render фазы. Весь смысл рендеринга состоял в том, чтобы определить, какие элементы нужно вставить, обновить или удалить, а какие компоненты должны вызвать методы жизненного цикла. И это то, что говорит нам список эффектов. И именно этот список элементов обходится во время commit фазы.</p><blockquote>Для целей отладки доступ к current<strong> </strong>дереву можно получить через current свойство fiber ноды. Доступ к дереву <em>finishedWork</em> можно получить через alternate свойство ноду <em>HostFiber</em> в текущем дереве.</blockquote><p>Основной функцией, которая выполняется во время commit фазы, является <a href="https://github.com/facebook/react/blob/95a313ec0b957f71798a69d8e83408f40e76765b/packages/react-reconciler/src/ReactFiberScheduler.js#L523">commitRoot</a>. В основном, она делает следующее:</p><ul><li>Вызывает метод <strong>getSnapshotBeforeUpdate</strong> на нодах, помеченных эффектом <strong>Snapshot</strong></li><li>Вызывает метод <strong>componentWillUnmount </strong>на нодах, помеченных эффектом <strong>Deletion</strong></li><li>Выполняет все обновления DOM дерева</li><li>Устанавливает дерево <strong>finishedWork </strong>как текущее</li><li>Вызывает метод <strong>componentDidMount</strong> на нодах, помеченных эффектом <strong>Placement</strong></li><li>Вызывает метод <strong>componentDidUpdate </strong>на нодах, помеченных эффектом <strong>Update</strong></li></ul><p>После вызова метода getSnapshotBotBeforeUpdate перед мутацией, React коммитит все побочные эффекты в дереве. Он делает это за два прохода. Первый проход выполняет все обновления DOM дерева. Затем React присваивает дерево finishedWork дереву FiberRoot, отмечая дерево WorkInProgress как current дерево. Это делается после первого прохождения commit фазы, чтобы предыдущее дерево все еще оставалось текущим во время выполнения componentWillUnmount, но перед вторым проходом, чтобы законченная работа была текущей во время componentDidMount/Update. Во втором проходе React вызывает все остальные методы жизненного цикла и коллбеки. Эти методы выполняются отдельно, так что все обновления во всем дереве уже были совершены.</p><p>Вот функция, которая выполняет описанные выше действия:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/42eaa612c0249e10ec282d43a4d9148d/href">https://medium.com/media/42eaa612c0249e10ec282d43a4d9148d/href</a></iframe><p>Каждая из этих подфункций реализует цикл, который итерируется по списку эффектов и проверяет тип эффектов. Когда он обнаруживает эффект, связанный с назначением функции, он применяет его.</p><h4>Методы жизненного цикла перед мутацией</h4><p>Вот, например, код, который итерируется по дереву эффектов и проверяет, имеет ли нода эффект Snapshot:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f23c8556747ba1a718472b7f18e1f705/href">https://medium.com/media/f23c8556747ba1a718472b7f18e1f705/href</a></iframe><p>Для классового компонента этот эффект означает вызов метода <strong>getSnapshotBeforeUpdate</strong>.</p><h4>Обновления DOM</h4><p><a href="https://github.com/facebook/react/blob/95a313ec0b957f71798a69d8e83408f40e76765b/packages/react-reconciler/src/ReactFiberScheduler.js#L376">commitAllHostEffects</a> — это функция, в которой React выполняет обновление DOM. Функция определяет тип операции, которая должна быть выполнена для ноды, и выполняет ее:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e8869bb06a9e50607b2dc72374e129bf/href">https://medium.com/media/e8869bb06a9e50607b2dc72374e129bf/href</a></iframe><p>Интересно, что React вызывает метод componentWillUnmount как часть процесса удаления в функции commitDeletion.</p><h4>Методы жизненного цикла после мутации</h4><p><a href="https://github.com/facebook/react/blob/95a313ec0b957f71798a69d8e83408f40e76765b/packages/react-reconciler/src/ReactFiberScheduler.js#L465">commitAllLifecycles</a> это функция, в которой React вызывает <strong>componentDidUpdate </strong>и <strong>componentDidMount</strong>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=66485d12bd37" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Дорога к Prettier]]></title>
            <link>https://medium.com/breadhead-stories/%D0%B4%D0%BE%D1%80%D0%BE%D0%B3%D0%B0-%D0%BA-prettier-6c249ca4fcee?source=rss-547898b45720------2</link>
            <guid isPermaLink="false">https://medium.com/p/6c249ca4fcee</guid>
            <category><![CDATA[разработка]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[prettier]]></category>
            <dc:creator><![CDATA[Владимир Голотин]]></dc:creator>
            <pubDate>Thu, 20 Dec 2018 13:41:43 GMT</pubDate>
            <atom:updated>2018-12-20T13:55:41.158Z</atom:updated>
            <content:encoded><![CDATA[<p>Мы в <a href="https://breadhead.ru/">Breadhead</a> задумались о внедрении <a href="https://prettier.io/">Prettier</a> в проекты когда дизайнер, который учился разработке, верстал наш новый сайт. Он имел небольшой опыт работы с JS и форматирование кода руками казалось ему сложным.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ODJ3DFXcUs3P6UMNor0u6w.png" /></figure><p>К Prettier мы присматривались и раньше, но в тот момент нам не понравились:</p><ul><li>конфликты с линтерами</li><li>ненадежная работа с JSX</li><li>необходимость отказаться от своих предпочтений при форматировании кода.</li></ul><p>С тех пор Prettier стал лучше и его использование вместе с другими средствами разработки стало стандартом.</p><p>Для того, чтобы подружить Prettier и линтеры, мы использовали <a href="https://github.com/prettier/tslint-config-prettier">tslint-config-prettier</a> и <a href="https://github.com/prettier/eslint-config-prettier">eslint-config-prettier</a>, которые отключают конфликтные правила.</p><p>Для форматирования кода перед коммитами мы использовали <a href="https://github.com/typicode/husky">husky</a> и <a href="https://github.com/okonet/lint-staged">lint-staged</a>, которые позволяют выполнять скрипты в гит хуках.</p><p>Спустя время то, что казалось недостатками Prettier было принято как достоинства. «Скудных» возможностей настройки оказалось достаточно, чтобы работать с линтерами без конфликтов. Бескомпромиссность правил помогла сделать код однороднее.</p><p>Теперь мы больше не дискутируем о стиле кода и не тратим время на его форматирование. Новым разработчикам легче войти в проект и легче писать код без боли.</p><p>Меня в этом инструменте привлекает его философия. В отличие от многих других Prettier реализует принцип единственной ответственности: занимается только форматированием и оставляет качество кода линтерам.</p><p>Настройки инструментов можно найти в <a href="https://github.com/breadhead/next-app">репозитории</a> нашей сборки на Гитхабе.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6c249ca4fcee" width="1" height="1" alt=""><hr><p><a href="https://medium.com/breadhead-stories/%D0%B4%D0%BE%D1%80%D0%BE%D0%B3%D0%B0-%D0%BA-prettier-6c249ca4fcee">Дорога к Prettier</a> was originally published in <a href="https://medium.com/breadhead-stories">Breadhead Stories</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>