Рубрики
Uncategorized

Лучшие практики для разработчиков реагирования в 2021 году

Может быть трудно поверить, но в этом году реагирует восемь лет. В технологии ландшафта … с меткой реагирования, WebDev, Devops.

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

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

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

В этой статье мы посмотрим на лучшие практики, которые применяются к реакции в 2021 году.

Конвенции

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

const myComponent = () => 
Hello World!
;

ReactDOM.render(, document.querySelector('#app'));

Это связано с тем, что стандартный трансформатор JSX от Babel (или Tymdercript) использует Конвенцию именования для решения того, передавать ли строку или идентификатор для реагирования.

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

const myComponent = () => React.createElement("div", null, "Hello World!");

ReactDOM.render(React.createElement("myComponent", null), document.querySelector('#app'));

Это не то, что мы хотим. Вместо этого мы можем использовать PascalCase. В этом случае трансформатор JSX обнаружит использование пользовательского компонента и требуемой ссылки.

const MyComponent = () => 
Hello World!
;

ReactDOM.render(, document.querySelector('#app'));

В этом случае все хорошо:

ReactDOM.render(React.createElement(MyComponent, null), document.querySelector('#app'));

Хотя другие конвенции менее строгие, их следует все еще следовать. Например, имеет смысл использовать цитируемые строковые атрибуты вместо выражений JSX:

// avoid


// better

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

Говоря о конвенциях и реквизитах, они также должны выполнять стандартные Конвенции JS именования использования CAMELCASE.

// avoid
const MyComponent = ({ is_valid, Value }) => {
  // ...
  return null;
};

// better
const MyComponent = ({ isValid, value }) => {
  // ...
  return null;
};

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

// avoid
const MyComponent = ({ style, cssStyle }) => {
  if (style === 'dark') {
    // ...
  }

  // ...
  return 
...
;
};

// better
const MyComponent = ({ kind, style }) => {
  if (kind === 'dark') {
    // ...
  }

  // ...
  return 
...
;
};

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

Разделение компонентов

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

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

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

const MyComponent = () => {
  const [data, setData] = React.useState();

  React.useEffect(() => {
    let active = true;

    fetch('...')
      .then(res => res.json())
      .then(data => active && setData(data))
      .catch(err => active && setData(err));


    return () => {
      active = false;
    };
  }, []);

  return (
    data === undefined ?
      
Loading ...
 :
      data instanceof Error ?
        
Error!
 :
        
Loaded! Do something with data...

  );
};

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

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

const MyComponent = ({ error, loading, data }) => {
  return (
    loading ?
      
Loading ...
 :
      error ?
        
Error!
 :
        
Loaded! Do something with data...

  );
};

const MyLoader = () => {
  const [data, setData] = React.useState();

  React.useEffect(() => {
    let active = true;

    fetch('...')
      .then(res => res.json())
      .then(data => active && setData(data))
      .catch(err => active && setData(err));

    return () => {
      active = false;
    };
  }, []);

  const isError = data instanceof Error;

  return (
    
  );
};

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

function useRemoteData() {
  const [data, setData] = React.useState();

  React.useEffect(() => {
    let active = true;

    fetch('...')
      .then(res => res.json())
      .then(data => active && setData(data))
      .catch(err => active && setData(err));

    return () => {
      active = false;
    };
  }, []);

  const isError = data instanceof Error;

  return [data === undefined, !isError ? data : undefined, isError ? data : undefined];
}

const MyComponent = () => {
  const [loading, data, error] = useRemoteData();

  return (
    loading ?
      
Loading ...
 :
      error ?
        
Error!
 :
        
Loaded! Do something with data...

  );
};

Крючки

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

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

Имейте в виду, что некоторые крючки могут помочь вам с оптимизациями производительности:

  • Усимер помогает избежать дорогих расчетов на каждом рендере.
  • USECallback производит стабильные обработчики, аналогично USEMEMO, но более удобно ориентирован на обратные вызовы.

В качестве примера давайте посмотрим на следующий код без USEMEMO:

const MyComponent = ({ items, region }) => {
  const taxedItems = items.map(item => ({
      ...item,
      tax: getTax(item, region),
  }));

  return (
      <>
        {taxedItems.map(item => 
  • 
          Tax: {item.tax}
        
    • )}
      
  );
};

    Учитывая, что в этом массиве могут быть много предметов, и что операция GetTax довольно дорога (без каламбула), у вас будет довольно плохое время повторного рендеринга, предполагая минимальные предметы и изменения региона.

    Поэтому код будет претендовать на пользу от USEMEMO:

    const MyComponent = ({ items, region }) => {
  const taxedItems = React.useMemo(() => items.map(item => ({
      ...item,
      tax: getTax(item, region),
  })), [items, region]);

  return (
      <>
        {taxedItems.map(item => 
  • 
          Tax: {item.tax}
        
    • )}
      
  );
};

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

    Более тонкий вопрос — отсутствие упрека. Давайте посмотрим на какой-то очень универсальный код:

    const MyComponent = () => {
  const save = () => {
    // some computation
  };
  return ;
};

    Теперь мы ничего не знаем о других комбинации, но здесь есть некоторые возможные изменения, возникающие здесь, например:

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

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

    Легкий выход — это написать то же самое, используя USECallback:

    const MyComponent = () => {
  const save = React.useCallback(() => {
    // some computation
  }, []);
  return ;
};

    Теперь рекомпропушенный обратный вызов принимается только в том случае, если одно из зависимостей, приведенных в массиве. В противном случае возвращается предыдущий обратный вызов (например, стабильная ссылка).

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

    Компоненты

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

    // no memoed component
const MyComponent = ({ isValid }) => (
  
    
    status
  
    
);

// memoed component
const MyComponent = React.memo(({ isValid }) => (
  
    
    status
  
    
));

    Реагистрационная документация вполне подробно о записке. Он говорит: «Если ваш компонент оказывает тот же результат, учитывая одинаковые реквизиты, вы можете обернуть его в вызов, чтобы отреагировать. Мемно для повышения производительности в некоторых случаях путем воспоминания. Это означает, что реагирование будет пропустить рендуринг компонента и повторно использовать последний результат оказанных данных ».

    Имейте в виду, что — как и любое другое сравнение, сделанное реагированием — реквизиты только неглубоко сравниваются. Следовательно, эта оптимизация применяется только в том случае, если мы осторожны, что пройти. Например, если мы используем USEMEMO и другие методы для сложных реквизитов, таких как массивы, объекты и функции.

    Возможно, вы заметили, что мы использовали исключительно функциональные компоненты. На самом деле, поскольку введение крючков, вы можете практически работать без классов компонентов.

    Есть только две возможные причины, чтобы еще использовать компоненты класса:

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

    Однако даже в этих случаях вам может просто потребоваться написать один компонент Ract Class для удовлетворения ваших потребностей. Посмотрите на эту границу:

    export class Boundary extends React.Component {
  state = {
    error: undefined,
  };

  componentDidCatch(error) {
    this.setState({
      error,
    });
  }

  render() {
    const { error } = this.state;
    const { children, ShowError } = this.props;

    if (error) {
      return ;
    }

    return children;
  }
}

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

    Операторы

    Некоторые операторы могут быть использованы для упрощения конструкции дерева в реакции. Например, Торговый оператор позволяет нам написать код, который выглядит так:

    
  {currentUser ? {currentUser} : Not logged in}

    Логические операторы, такие как && и || Может также быть полезным, но есть несколько ловушек для остеренения. В качестве примера посмотрите на этот фрагмент кода:

    
  {numUsers && There are {numUsers} users logged in.}

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

    
  There are 5 users logged in.

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

    
  0

    Что может быть не то, что мы хотели, поэтому булевое преобразование или более явное сравнение может помочь здесь. В общем, следующее более читаемо:

    
  {numUsers > 0 && There are {numUsers} users logged in.}

    Теперь в нулевых пользователей Edge Cate Pictory мы получаем:

    Использование оператора Ternary в качестве эксклюзивного булевого оператора избегает проблемой полностью. Но как насчет государства, где мы не хотим что-либо оказывать? Мы могли бы либо использовать False или пустой фрагмент:

    
  {numUsers ? There are {numUsers} users logged in. : <>}

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

    Заключение

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

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

    Оригинал: «https://dev.to/grapecity/best-practices-for-react-developers-in-2021-42a»