Как стать автором
Обновить

Комментарии 24

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


Проблема с сравнением по ссылке тоже яйца выеденного не стоит: автор же сам разлагает config на url, skip и take, так в чём проблема их в массив зависимостей и засунуть? Вода сплошная для того, чтобы статья внушительнее выглядела.


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

Я полностью согласен с автором статьи. Хуки — это зло. Особенно для начинающих разработчиков.


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


Я работал над проектов в котором хуки сыграли злую роль, из-за этих пропавших зависимостей и из-за того, что нет контроля над мемоизацией, а архитектурных навыков у начинающих разработчиков мало, встречались компоненты с 5-8 useEffect, 2-3 useState в одном компоненте, который перерендеривался по 20 раз. Включив подсветку обновлений в React devtolls (которую убрали в одном из обновлений sic!, потом вернули), приложение было похоже на новогоднюю гирлянду.


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


Хуки выглядят просто, а на деле — очень опасные и коварные стейт-машины.

Вы пишете так, как будто в этом хуки виноваты. И как будто с классовыми компонентами в реакте очень сложно не по делу перерисовывать компоненты (нет).

Я видел немаленьких размеров UI на реакте, который полностью на 100% перерисовывал себя во всех без исключениях ситуациях (даже если по нему просто мышкой поводить, срабатывали onmousemove). Хуков там было использовано 0 — в те времена о них только еще объявили.
Вы пишете так, как будто в этом хуки виноваты.
Именно так я и пишу. Этот инструмент более требователен к учидчивости, пониманию внутренних концептов, нежели Реакт без хуков.

С хуками проще сделать неподдерживаемое приложение.


Из опыта нескольких SPA с хуками/без и нескольких разработчиков разного уровня.

С хуками проще сделать неподдерживаемое приложение.

Это пустая риторика. Да, хуки представляют меньше «архитектурных границ». Нет, наличие любого количества архитектурных границ не мешает писать говнокод. Есть ли статистическая зависимость одного от другого? Не знаю, и не думаю, что кто-то проводил хорошие исследования на этот счёт. Всё, что я тут вижу — это голословные утверждения, которые «интуитивно» похожи на правду, и которые часто выдаются за реальное положение вещей через тезисы в духе «общеизвестно, что на C++ говнокодить проще, чем на яве» (или наоборот, в зависимости от того, что нравится и не нравится человеку, это высказывающему).

Меж тем, мой личный опыт говорит мне о том, что говнокодят всегда и везде, вне зависимости от выбранных инструментов. Например, уже несколько лет я сталкиваюсь с говноприложениями на react+redux, в то время как публичный дискурс мне постоянно утверждает, что редакс — это enterprise-grade, куча рамок, и минимизация возможностей «неокрепших джуниоров» чего-нибудь напортачить. А потом меня зовут на очередной нерасширяемый или погребенный под проблемами производительности проект и просят что-то сделать (что обычно превращается в классическое «все переписать»).

Все верно, в редаксе как раз очень мало архитектурных границ.
Вот, redux-toolkit, надеюсь, может чуть улучшить ситуацию.


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

Мой опыт — хорошие программисты делают нормально с любыми инструментами (потому что сами их выбирают сообразно задачам), плохие — делают плохо с любыми (в том числе и выбранными за них хорошими). Работу плохих программистов можно использовать тогда, когда за её качеством приглядывают хорошие. Если плохих программистов отправить самостоятельно резвиться в каких угодно жестких архитектурных рамках — результат всё равно будет плачевен.

Ну не разрешайте использовать useEffect людям, которые не умеют с ним работать, в чем проблема?

Хоть кто-то правду написал!

Поводу о чём? Не нравятся хуки работайте с классами, как будто Вам запретили из использовать.

О хуках.

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

Документацию я прочитал и сразу понял, что хуки — это бред. Но тут поднялся дичайший хайп на тему хуков, и я уже начал сомневаться: кто же тут безумен, я или все эти хайпожоры. А теперь последние сомнения отпали.

Одна рекламная статейка развенчала сомнения? Около года с хуками работаю и всё гораздо удобнее, компактнее, нежели с классами. А недостатки есть и там и там.

Возврат исполняемой функции из хука

Зачем?

Ну вот, кто-то начинает триггерить фазу "освобождение от иллюзий" по хукам. По поводу "В текущем ландшафте JavaScript нет ничего подобного" — хук useEffect как паттерн это стандартная асинхронщина через event loop:


let prevMyProp = null;

function Component({ myProp }) {
  setTimeout(() => {
    if (prevMyProp === myProp) return;

    1 + 1;

     prevMyProp = myProp;
  }, Component.didRenderTimeout) // по большей части 0

  // то же самое хуком
  React.useEffect(() => {
    1 + 1;
  }, [myProp])

  return <div />
}

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

за вычетом двух проблем — порядок хуков и их количество должно соблюдаться и передача объектов в массив зависимостей — все остальное — это by design и в общем-то плюс.
Первая проблема нерешаема вообще но вобщем-то терпима и ничего страшного за собой не несет;
Вторая проблема решается (или подталкивает к решению) через оптимизацию зависимостей и понимание того откуда приходят эти зависимости, и решиться окончательно когда завезут поддержку tuple и record — массивы и объекты которые сравниваются по значению а не по референсу;
При этом хуки несут:
1) инкапсуляцию логики; теперь любую сложную логику можно хранить в одном месте и видеть порядок выполнения;
2) более простую типизацию, хуки принимают и отдают (как правило) легко типизируемые структуры данных;
3) более простую логическую модель. Не нужно знать о конкретных компонентах и их lifecycle, достаточно знать на самом деле что есть хуки для хранения состояния (useState, и useRef) и для вызова эффектов (useEffect/useLayoutEffect). Все остальное — композиция этих двух типов хуков;
4) легковесность. Хуки прекрасно выносятся в пакеты и живут потом в react/react-native проектах;
5) оптимизация и дебаг. Если у вас тысяча и один рендер вызываются на каждый чих то гораздо проще локализовать источник проблемы и оптимизировать хук чем продираться через древо компонентов.


Являются ли хуки серебряной пулей? нет конечно, ни один из инструментов/паттернов не является. Да, асинхронные операции чуть более боль чем хотелось бы и массив зависимостей может выстрелить в ногу при невнимательности.
К тому же хуки абсолютно опционально, и если бы комьюнити (ну или у вас в конкретном проекте) решили что классы это то что вам нужно — никто не запрещает продолжать пользоваться ими.

Не соглашусь. Опициональность в контексте речи о Реакте подразумевает заменяемость на классы. Хуки уже не заменяемы в некоторых случаях habr.com/ru/company/yandex/blog/514016/#comment_21933114

совершенно забыл про transition хуки. Да, небольшой дескреп все же есть (ErrorBoundary только классы, а некоторые фичи suspense — только хуками) но как правило эти элементы абстрагированы в библиотеки.
По большому счету можно продолжать использовать классы.

Проблема не в хуках, а в реакте. Ни у одного другого фреймворка нет столько статей о том, как выполнить простое действие — управлять данными программы. Всё потому, что его авторы раньше никогда не писали фронтенд и попытались натянуть подходы бекенда на среду с другими требованиями и характеристиками. Отсюда и их постоянные смены парадигм и изменение подходов, они поняли, что что-то делали не так, но не хотят признавать ошибки. Они ссылаются на научные статьи, чтобы описать маленький кусок логики, но это бронированная дверь, приставленная к деревянному сараю. Концентрируясь на малом они упускают большое. После хуков будет ещё одно решение, потом может быть ещё несколько, пока они не придут к подходу, давно используемому в отрасли и применяющемуся в MobX (костылю, позволяющему реакту ходить), Angular и Vue.
При чём тут Angular или Vue, чем они лучше реакта?
Работой со стейтом. У них изменения трекаются в момент выполнения, в реакте — в момент рендера. В результате в реакт мы имеем быстрый первый рендер, но вся последующая работа с программой будет тормозить гораздо сильнее, чем при общепринятом подходе. Если объяснять на пальцах, то angular, vue и остальные записывают дифф изменений стейта и при следующем рендере просто его применяют, это очень быстрая операция. Реакт ничего не записывает, а вместо этого сравнивает дерево пропсов заново при каждом рендере, в этом случае время выполнения растёт нелинейно при росте числа компонентов и свойств (O(N^X), где X > 1). Лет 20 назад разработчиков за такое увольняли, но времена сейчас не те, ассимптотическую сложность не оценивают и половина даже не понимает. Общепринятый подход с трекингом изменений даёт линейный рост (X=1), то есть с ним можно создавать программы любого размера. Реакт же хорошо работает на маленьких модельных примерах, в синтетических бенчмарках, но когда приложение становится достаточно большим — начинаются тормоза, и чтобы их избежать начинаются ухищрения, сильно снижающие developer experience. Так например иммутабельность в redux нужна не из за того, что это хорошо, а чтобы помогать реакту проводить сравнение дерева свойств. Без неё он просто захлебнётся. Вас не спрашивают, хотите вы иммутабельность или нет, это необходимый довесок, потому что без этого пересчёт дерева будет занимать слишком много времени. Они оправдали собственные недоработки философией, что якобы так правильнее, ФП, все дела, хотя настоящая причина — что это один из немногих способов заставить реакт сносно работать в больших приложениях. Другой вариант — прописывать componentShouldUpdate в каждом компоненте, чтобы по-умному трекать изменения в дереве, но это настолько утомительно, что никто этим не занимается. С общепринятым же подходом, используемым в angular, vue и куче других библиотек, изменения трекаются в момент внесения и дерево сравнивать не нужно. Это похоже на индекс в базе данных. Вы просто сохраняете то, что вам будет нужно уже через несколько миллисекунд, чтобы не вычислять это по всему объёму данных в момент рендера. Это же так логично. Как результат, не нужно коверкать developer experience, вы можете просто присвоить значение стейту, можете мутировать, можете вынести во внешний модуль, можете добавлять к данным методы для их обработки и нативные объекты вроде Map, Set и т.п… В реакт это считается антипаттерном, потому что реакт не может это съесть, ему нужно разжевать и положить в рот. Вот, для сравнения, как стейт может создаваться во vue:
const state = {};

Это то, что в мире реакта называют «магией», потому что они не поняли, как это работает. И эта одна строчка на самом деле всё, что вам нужно, чтобы работать с данными в общепринятом подходе. Вы можете импортировать его в компоненты, вы можете изменять его как угодно и все изменения будут автоматически отражены в визуальной части. Именно поэтому про работу с данными во Vue и не пишут статей на хабре. Что о них писать, если они просто работают, надёжно и интуитивно.
НЛО прилетело и опубликовало эту надпись здесь
Зарегистрируйтесь на Хабре, чтобы оставить комментарий