10 самых распространенных ошибок в коде React, которые возможно делаете и вы


Содержание материала:

[Из песочницы] Самые распространенные ошибки в вашем React коде, которые вы (возможно) делаете

2020-7-8 15:24

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

Весь код написан в ES6 стиле, поэтому, что бы повторить его вам нужно использовать Babel в вашем проекте (а еще есть такие кто его не использует?).

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

Если вам интересно, то добро пожаловать под кат.

Подробнее читайте на megamozg.ru .

[Из песочницы] Самые распространенные ошибки в вашем React коде, которые вы (возможно) делаете

Вдохновленный прочитанными статьями на медиуме, я решил написать свою статью и рассказать вам как можно избегать самых распространенных ошибок в вашем React приложении и для чего это нужно делать. habrahabr.ru »

Партнеры

Реклама

Самое свежее

[Из песочницы] Самые распространенные ошибки в вашем React коде, которые вы (возможно) делаете

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

Добавляем в jsx циклы и условия

Если вы используете библиотеку React, то наверняка используете и jsx. Конечно, это не обязательно, и можно писать только js, используя React. createElement, но с jsx получится гораздо лаконичнее, что повышает читаемость.

[Из песочницы] Самые распространенные ошибки в вашем React коде, которые вы (возможно) делаете

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

Весь код написан в ES6 стиле, поэтому, что бы повторить его вам нужно использовать Babel в вашем проекте (а еще есть такие кто его не использует?).

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

Если вам интересно, то добро пожаловать под кат.

Вы сможете позднее найти их в git и добавить в свой проект. В скобках перед каждым параграфом я оставил ссылку на eslint правило.

(react/forbid-component-props)

Избегайте этого, так как вы добавите много сложности в ваши компоненты. Первая распространенная ошибка это передача ‘style’ и ‘className’ как props в ваш компонент.

Вместо это можно использовать библиотеку ‘classnames’ и добавить интересные вариации в ваш компонент (если вы используете css классы):

const = this.props;
const component : hasBorder,
>);

(react/forbid-prop-types)

Не используйте PropTypes.any, PropTypes.array и PropTypes.object. Следующая ошибка — не информативные propTypes. Это позволит вам оставить хорошую документацию на будущее, и вы (или другой разработчик) еще не раз скажите себе большое спасибо. Описывайте ваши props как можно подробнее.

(react/forbid-foreign-prop-types)

Не используйте propTypes другого компонента: Давайте продолжим с propTypes.

import SomeComponent from ‘./SomeComponent’;
SomeComponent.propTypes;

Создайте файл в котором вы будете содержать в порядки ваши глобальные propTypes:

Это поможет babel-plugin-transform-react-remove-prop-types убрать propTypes из продакшен кода и сделать ваше предложение чуточку легче.

(react/no-access-state-in-setstate)

Следующая ошибка очень интересная:

Потому что setState это асинхронная функция состояния state в обоих случаях будет одинаковым.
this.state.counter будет равен 1 и мы получим:

incrementCounter = () => this.setState(< counter: 1++ >);
incrementCounter = () => this.setState(< counter: 1++ >);

Для того, что бы это избежать можно использовать setState callback который получает как аргумент прошлое состояние state:

(react/no-array-index-key)

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

React будет вынужден перерендерить все UserComponents после добавленного нового, так как индекс будет изменен для большого кол-ва компонентов. React использует prop key как ссылку к DOM элементу, и это помогает ему быстро найти и отрендерить нужный компонент (все, конечно, сложнее, но я упростил специально).
Что случиться если вы добавите нового юзера в середину массива? Очень простой выход это id, которые вы получаете из вашей базы данных: Используйте уникальные ключи вместо этого.

(react/no-did-mount-set-state), (react/no-did-update-set-state)

Если вы попытаетесь обновить state в componentDidUpdate или componentDidMount методах, вы получите бесконечный цикл ре-рендера. Эта ошибка так же очень часто встречается в моей практике. Если вы поменяете state после того как компонент замаунтился в DOM или уже обновился, вы запустите проверку заново и заново и заново. React начинает проверку на ре-рендер когда у компонента меняется state или props.

(react/no-direct-mutation-state)

Неконтролируемая мутация state приведет к необнаруживаемым багам и, как следствие, к большим проблемам. Мутация state это очень большая ошибка. И их вы можете использовать с Redux/MobX/Любой библиотекой state менеджмента. Мое персональное мнение это использование immutable-js, как библиотеку, которая добавляет иммутабельные структуры. Так же вы можете использовать deepClone из lodash для клонирования state и последующей мутации клона или использовать новую фичу JS — деструкцию (destructuring):

(react/prefer-stateless-function)

Если ваш компонент не использует state, сделайте его stateless компонентом (мне больше нравиться термин ‘pure component’): Данное правило описывает больше улучшение вашего кода и приложения, чем ошибку, но я, все же, рекомендую следовать этому правилу.

class MyComponentWithoutState extends React.Component < render() < return

(react/prop-types)

Думайте об этом как о документировании вашего кода. Пожалуйста, всегда добавляйте проверку на типы props (propTypes) если ваш компонент получает props. PropTypes поможет вам понять и разобраться, что ваш компонент может отрендерить, а так же, что ему нужно для рендеринга. Вы еще не раз скажете себе ‘спасибо’ за это (а может быть и мне :)).

(react/jsx-no-bind)

Не Используйте Bind И Arrow Function В Jsx. Очень распространенная и большая ошибка которую я видел в коде много раз. Больше.
Самое жаркое место в аду ждет того кто пишет .bind(this) в JSX.
Каждый раз когда компонент рендериться ваша функция будет создаваться заново, и это может сильно затормозить ваше приложение (это связано с тем, что garbage collector будет вынужден запускаться значительно чаще). Никогда. Вместо .bind(this) вы можете использовать Arrow functions определенным образом:

(react/jsx-no-target-blank)

Для меня выглядит очень странно, что люди до сих пор делают эту ошибку. Ошибка связанная с безопасностью. Очень просто: Очень много людей написало очень много статей на эту тему в 2020.
Если вы создаете ссылку с target=’_blank’ атрибутом не забудьте добавить к ней rel=’noreferrer noopener’.

Спасибо вам!

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

10 типичных ошибок программирования

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

Переполнение буфера

Исторически одна из самых опасных ошибок. Именно благодаря ей на свет появились черви Морриса и Nimda, которые в сумме заразили несколько миллиардов компьютеров. Суть ошибки проста: из-за неправильного вычисления позиций записи в память пользователь может внести данные «за пределы» буфера. В лучшем случае, это приведёт к ошибке, а потенциально – к тому, что хакер добавит в исполняемый код «вредоносные» вставки. Вот как это работает графически:

SQL-инъекция

SQL инъекция – хакерская атака, позволяющая получить им прямой доступ к базе данных. Используя простую конкатенацию SQL-команд, злоумышленники считывают базы данных, удаляют и добавляют данные, устанавливают собственные ссылки.

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

Инъекции команд ОС

Некоторое ПО использует встроенные команды операционной системы, например, для извлечения данных компьютера или запуска приложения. В этом случае, здесь может возникнуть схожая ошибка – инъекции команд вашей ОС. Без надлежащей проверки введённых данных, злоумышленник получает возможность влезть в ваш компьютер, изменить разрешения файлов, установить приложение, украсть данные или удалить что-то важное. Как это происходит – представляют более-менее все, кто хоть раз имел дело с компьютерным вирусом.

Переполнение числовых типов

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

Теперь представьте, что вам надо сложить 2 числа этого типа 65530 и 20.

Результат 65555 не впишется в тип short, а на выходе вы получите непредсказуемое значение. Таким образом, дальнейшая работа с этой переменной приведёт к заведомо неправильному результату.

Неправильная оценка размера массива

Бытует стереотип, что ошибки доступа к несуществующему индексу массива возможны только в C или C++, так как здесь используется ручное управление памятью. Это не так: в Java, Python, JavaScript и других «автоматических» языках подобные просчёты разработчика – не редкость. При неправильной оценке индекса массива пользователь получает доступ к неиспользуемым ячейкам памяти. Это, в свою очередь, приводит к критическим ошибкам в программе.

Использование ресурсов без ограничений

В ручном распределении памяти проблема имеет глобальный характер. Без проверок и ограничений происходит сбой распределения – одни данные занимают пространство, потенциально предназначенное для других. В результате они или игнорируются, или возникает ошибка, или вы получаете программу, которая будет «съедать» всю память машины во время исполнения.

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

Указатель на освобождённую память

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

Вывод нулевого указателя

До инициализации указатель имеет нулевое значение. Работа с ним приводит к ошибке. К примеру, в Java это NullPointerException. Ошибка хоть и детская, но очень распространена, поэтому избежать появления в этом рейтинге не могла.

Отсутствие инициализации

Локальные переменные существуют только внутри функции или небольшого блока, поэтому иногда программисты игнорируют их нормальную инициализацию. Между тем, если присвоение стартового значения оставить на откуп ПО, вместо ожидаемого нуля или пустого символа, вы можете увидеть ошибку Missing Initialization или какой-то мусор из памяти.

Рискованные алгоритмы

При работе с персональными данными необходимо надёжно их защищать. Не стоит полагаться на собственные силы, ведь в мире существует множество готового ПО и алгоритмов, которые работают куда лучше вашего неопытного мозга. Впрочем, даже к их использованию надо подходить с умом. Так алгоритм хэширования SHA-1 устарел и легко взламывается современными хакерами, поэтому стоит отдать предпочтение SHA-2 или SHA-3. В противном случае, вы рискуете не только репутацией своего ПО, но и вполне осязаемыми деньгами.

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

Основано на статье Jay Sridhar для портала MakeUseOf.

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


Переполнение буфера

Исторически одна из самых опасных ошибок. Именно благодаря ей на свет появились черви Морриса и Nimda, которые в сумме заразили несколько миллиардов компьютеров. Суть ошибки проста: из-за неправильного вычисления позиций записи в память пользователь может внести данные «за пределы» буфера. В лучшем случае, это приведёт к ошибке, а потенциально – к тому, что хакер добавит в исполняемый код «вредоносные» вставки. Вот как это работает графически:

SQL-инъекция

SQL инъекция – хакерская атака, позволяющая получить им прямой доступ к базе данных. Используя простую конкатенацию SQL-команд, злоумышленники считывают базы данных, удаляют и добавляют данные, устанавливают собственные ссылки.

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

Инъекции команд ОС

Некоторое ПО использует встроенные команды операционной системы, например, для извлечения данных компьютера или запуска приложения. В этом случае, здесь может возникнуть схожая ошибка – инъекции команд вашей ОС. Без надлежащей проверки введённых данных, злоумышленник получает возможность влезть в ваш компьютер, изменить разрешения файлов, установить приложение, украсть данные или удалить что-то важное. Как это происходит – представляют более-менее все, кто хоть раз имел дело с компьютерным вирусом.

Переполнение числовых типов

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

Теперь представьте, что вам надо сложить 2 числа этого типа 65530 и 20.

Результат 65555 не впишется в тип short, а на выходе вы получите непредсказуемое значение. Таким образом, дальнейшая работа с этой переменной приведёт к заведомо неправильному результату.

Неправильная оценка размера массива

Бытует стереотип, что ошибки доступа к несуществующему индексу массива возможны только в C или C++, так как здесь используется ручное управление памятью. Это не так: в Java, Python, JavaScript и других «автоматических» языках подобные просчёты разработчика – не редкость. При неправильной оценке индекса массива пользователь получает доступ к неиспользуемым ячейкам памяти. Это, в свою очередь, приводит к критическим ошибкам в программе.

Использование ресурсов без ограничений

В ручном распределении памяти проблема имеет глобальный характер. Без проверок и ограничений происходит сбой распределения – одни данные занимают пространство, потенциально предназначенное для других. В результате они или игнорируются, или возникает ошибка, или вы получаете программу, которая будет «съедать» всю память машины во время исполнения.

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

Указатель на освобождённую память

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

Вывод нулевого указателя

До инициализации указатель имеет нулевое значение. Работа с ним приводит к ошибке. К примеру, в Java это NullPointerException. Ошибка хоть и детская, но очень распространена, поэтому избежать появления в этом рейтинге не могла.

Отсутствие инициализации

Локальные переменные существуют только внутри функции или небольшого блока, поэтому иногда программисты игнорируют их нормальную инициализацию. Между тем, если присвоение стартового значения оставить на откуп ПО, вместо ожидаемого нуля или пустого символа, вы можете увидеть ошибку Missing Initialization или какой-то мусор из памяти.

Рискованные алгоритмы

При работе с персональными данными необходимо надёжно их защищать. Не стоит полагаться на собственные силы, ведь в мире существует множество готового ПО и алгоритмов, которые работают куда лучше вашего неопытного мозга. Впрочем, даже к их использованию надо подходить с умом. Так алгоритм хэширования SHA-1 устарел и легко взламывается современными хакерами, поэтому стоит отдать предпочтение SHA-2 или SHA-3. В противном случае, вы рискуете не только репутацией своего ПО, но и вполне осязаемыми деньгами.

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

Основано на статье Jay Sridhar для портала MakeUseOf.

digitech

[Из песочницы] Самые распространенные ошибки в вашем React коде, которые вы (возможно) делаете

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

Топ-пост этого месяца:  Планировщик задач онлайн для достижения цели

Весь код написан в ES6 стиле, поэтому, что бы повторить его вам нужно использовать Babel в вашем проекте (а еще есть такие кто его не использует?).

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

Если вам интересно, то добро пожаловать под кат.

SavePearlHarbor

Ещё одна копия хабора

Топ 5 ошибок в моих ReactJS приложениях

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

1. Stateful компоненты (классы) хуже hook-ов

Пожалуй, начать стоит с наиболее нашумевшей фичи ReactJS, которая появилась в версии 16.8+ Вопреки некоторым убеждениям, эта фича была выстрадана ошибками предыдущих поколений разработчиков и решает множество проблем. Если вы все еще используете компоненты-классы вместо хуков в 2020-ом, то вы совершаете большую ошибку и просто еще не поняли, в чем их преимущество. Я не буду в этой статье подробно это объяснять, посмотрите лучше это замечательное видео Дена Абрамова, но я просто не мог начать эту статью иначе

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

2. Использование анонимных функций в качестве props

Если первая ошибка еще может быть воспринята, как дань моде, то знание второй, уверяю, спасет от бессонных ночей и головной боли. Ведь именно она заставялет приложение работать настолько неадекватно, что его пользователи могут навсегда разочароваться в ReactJS. А мы ведь хотим, чтоб пользователи его любили, так же, как и мы с вами, правда? Для избежания этой ошибки можно пользоваться очень простым правилом — никогда, НИКОГДА не передавать в качестве пропса компоненту анонимную функцию.

Более изощренный вариант этой ошибки может выглядеть как-то так (не читайте, если не знакомы с Redux):

В обоих вариантах, в конечно итоге, в props компонента попадает анонимная функция. Это плохо потому, что при каждом рендере родительского элемента, эта фукнция будет ссылаться на новый объект в памяти, а, значит, не будет равна сама себе предыдущей, и ваш компонент благополучно будет перерендерен без надобности. Это так сильно может тормозить производительность вашего приложения, что вы сами начнете плеваться и разочаровываться в React, но все дело в АНОНИМНЫХ ФУНКЦИЯХ в props-ах. Просто не делайте так никогда — и будьте счастливы.

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

Еще пара слов, как же написать правильно. Вот как:

3. Несколько экземпляров React в приложении

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

Пожалуйста, не пытайтесь запихнуть на одну страницу больше одного экземпляра React приложения. На самом деле, в документации React нет запрета на такой подход, я даже встречал рекомендации поступать именно так в некоторых статьях (и, конечно же, сам делал в своих приложениях подобное), НО оптимизация такого подхода и согласование всех частей приложения, в этом случае начинает занимать больше половины всего рабочего времени. Этого легко можно избежать: например, если вам нужно реагировать на какие-то события в legacy коде в вашем новом React-приложении, — вы можете использовать событийную модель. Например вот так:

4. Написание собственных библиотек, вместо существующих с открытым исходным кодом

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

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

5. Боязнь использовать чужой код

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

Но я так же научился понимать других разработчиков, их мысли и проблемы, с которыми они столкнулись. Видеть количество времени и сил, которые были потрачены (и не зра) на решение проблем. В 3х случаях из 5-ти, когда я берусь «улучшийть» чужой код — у меня в результате получается почти то же самое, что и было. Просто потому что на старте задачи ты, обычно, не видишь всех проблем, которые подстерегают тебя в будущем. Так что, сейчас я уважаю чужой код, каким бы странным и «устаревшим» он мне не казался. Что и вам советую.

Спасибо

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

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

9 принципов, которые должен знать новичок в React.js

Автор статьи: Cam Jackson . Оригинал статьи здесь . От переводчика: статья не лишена спорных или субъективных моментов, но, все же, большинство изложенных принципов достаточно полезны.

Я использую React.js с 2015 года. По большому счету, это не такой уж и большой срок, но в постоянно меняющемся мире JavaScript, этого достаточно, чтобы мнить себя умудренным старцем. Недавно я помог нескольким людям советами по началу работы с React, поэтому я подумал, что было бы неплохо опубликовать некоторые из них здесь, чтобы больше людей их увидели. Это все — принципы, которые я хотел бы знать, когда я начинал изучать React, или принципы, которые действительно помогли мне разобраться в React’e.

Я предполагаю, что вы уже знаете самые основы. Но если слова component , props , или state вам не знакомы, то вам лучше бы сначала прочитать официальные Hello World или Руководство. Также, я буду использовать JSX, потому что он предоставляет гораздо более краткий и выразительный синтаксис для написания компонентов.

1. Это просто библиотека отображения

Давайте сначала разберемся с основами. React это не очередной MVC-фреймворк или какой-либо другой фреймворк. Это всего лишь библиотека для рендеринга ваших отображений (views). Если вы пришли из мира MVC, то вам нужно осознать, что React это буква ‘V’ в этой аббревиатуре, и вы должны поискать где-нибудь в другом месте, когда дело доходит до ‘M’ и ‘C’, иначе в результате вы получите кучу дурно пахнущего React-кода. Подробнее об этом далее.

2. Делайте небольшие компоненты

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

Компонент представляет собой с двумя

для каждого элемента массива. Эта последняя часть, выдающая

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

3. Пишите функциональные компоненты

Ранее было два способа объявления React-компонента, первым был — React.createClass() :

Затем появился способ, использующий классы ES6:

React 0.14 представил новый синтаксис — объявление компонентов как функций от props:

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

Этот класс не такой плохой, как вообще могут быть классы. Мы уже выделили пару методов из метода render() , разделив его на небольшие блоки с понятными названиями. Задача вывода кратких версий последних записей блога решена. Теперь давайте перепишем тот же самый код, используя функциональный синтаксис:

Большая часть кода не изменилась, только теперь у нас голые функции вместо методов класса. Тем не менее, для меня это большая разница. Когда компонент разбит на функции, мне субъективно проще поймать тот момент, когда этот компонент уже пора разбить на более мелкие компоненты. Таким образом, “функциональный” синтаксис помогает мне следовать пункту №2.

В будущем, также, планируются оптимизации в React, которые сделают функциональные компоненты более эффективными, чем классовые. ( Update: оказалось что изменения в производительности функциональных компонентов сложнее, чем я думал. Я все еще рекомендую использовать функциональные компоненты, но если вас сильно тревожит производительность, то вам следует прочитать и понять это и это, и решить что работает лучше в вашем случае.)

Важно отметить, что функциональные компоненты имеют несколько “ограничений”, которые я бы, скорее, назвал их сильными сторонами. Во-первых, функциональному компоненту нельзя присвоить атрибут ref (подробнее о нем здесь). Хотя он и является удобным способом для взаимодействия с дочерними компонентами из родительского, но, по моим ощущениям, это Неправильный Способ Разработки на React. ref -атрибуты поощряют очень императивный и почти jquery-подобный подход к написанию компонентов, уводя нас в сторону от философии функциональности и однонаправленности потока данных, ради которой мы и выбираем React.

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

4. Создавайте компоненты, не имеющие состояние (stateless)

Должен сказать, что на данный момент самая большая боль, которую я ощутил создавая приложения на React, была вызвана компонентами, у которых было слишком много состояния (state).

Наличие состояния затрудняет тестирование компонентов

Нет ничего проще для тестирования, чем чистые функции. Так зачем же нам лишать себя возможности делать компоненты в виде чистых функций, добавляя к ним состояние? Во время тестирования компонентов с состоянием, нам приходится приводить компоненты к определенному состоянию, чтобы затем протестировать их поведение. Нам, также, приходится возиться со всем разнообразием комбинаций состояния (которое компонент может изменить в любой момент) и входных атрибутов ( props , которые компонент вообще не контролирует), и выяснять которые из них тестировать и как. А когда компоненты выполнены в виде простых функций от входных данных — тестировать намного легче. (Подробнее о тестировании ниже).

Наличие состояния затрудняет понимание работы компонента

Когда читаешь код компонента со сложным и развесистым состоянием, то приходится сильнее напрягать голову, чтобы уследить за всем что происходит. Постоянно возникают вопросы из разряда: “Это состояние уже инициализировано?”, “Что будет, если я поменяю состояние в этом месте?”, “Возникает ли здесь race condition?”. Просмотр компонентов, имеющих состояние, с целью понять их поведение, становится очень болезненным.


Наличие состояния слишком легко позволяет вставить в компонент бизнес-логику

На самом деле, просмотр компонентов с целью выявления логики поведения это не то, что мы должны делать. Вспомните, React это библиотека отображения, таким образом логика рендеринга в компоненте это ОК, но бизнес-логика в компоненте — это очень плохо. И когда большая часть состояния приложения уже находится прямо здесь в компоненте и легко доступна с помощью this.state , то возникает большой соблазн добавить сюда же логику вроде подсчетов чего-либо или валидацию, чего не должно быть в компоненте. Возвращаясь к одному из предыдущих пунктов, это сильно затрудняет тестирование — вы не можете протестировать логику рендеринга, без путающейся под ногами бизнес-логики, и наоборот!

Наличие состояния затрудняет обмен информацией с другими частями приложения

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

Конечно, иногда имеет смысл оставлять определенную часть состояния приложения “на совести” конкретного компонента. В таком случае, вполне можно использовать this.setState . Это допустимая и легальная возможность API React-компонентов, и я не хочу чтобы сложилось впечатление, что это нужно запретить. Например, когда пользователь вводит текст в поле, то, скорее всего, всему приложению не нужно знать о каждом нажатии клавиши. Во время этого, компонент input может менять свое промежуточное состояние до тех пор, пока не потеряет фокус, после чего итоговый текст отправится наружу и станет частью состояния, хранящегося где-нибудь в другом месте. Этот сценарий недавно упомянул мой коллега, и я считаю, что это хороший пример.

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

5. Используйте Redux.js

В первом пункте я сказал, что React это только отображение. Тогда возникает очевидный вопрос “Где должны храниться состояние и логика?”. Я рад, что вы спросили!

Возможно вы уже слышали о Flux, который представляет собой стиль/шаблон/архитектуру для создания web-приложений, в основном использующих для рендеринга React. Существует несколько фреймворков, воплощающих идеи Flux, но я без сомнения могу порекомендовать Redux.js *.

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

  1. Компоненты получают функции обратного вызова, как props , которые они вызывают, когда возникают события UI
  2. Эти функции обратного вызова создают и возвращают действия, основываясь на информации о событии
  3. Редьюсеры обрабатывают действия, вычисляя новое состояние
  4. Новое состояние всего приложения отправляется в единое хранилище
  5. Компоненты получают новое состояние через props и перерисовывают себя там, где это необходимо

Большая часть перечисленных концепций не является уникальной для Redux, но Redux реализует их просто и без излишеств, с помощью минимального API. Перенося приличного размера проект с Alt.js на Redux, я обнаружил несколько преимуществ последнего. Вот самые значительные из них:

  • Редьюсеры это чистые функции, все что они делают это oldState + action = newState . Каждый редьюсер вычисляет отдельный кусок состояния. Все эти куски, впоследствии, объединяются вместе, формируя целое приложение. Это значительно упрощает тестирование бизнес-логики и логики изменения состояния.
  • API меньше, проще и лучше документирован. Я обнаружил, что его концепции гораздо проще и легче изучать, и, следовательно, намного легче разобраться в потоках действий и информации в приложении.
  • Если его использовать так, как рекомендовано, то лишь незначительное число компонентов будет напрямую зависеть от Redux. Все остальные компоненты просто получают состояние и функции обратного вызова через props . Таким образом, компоненты остаются очень простыми и уменьшается завязанность на конкретном фреймворке.

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

  • Immutable.js — немутабельные структуры данных для JavaScript! Используйте их для хранения состояния, чтобы быть уверенным, что оно не меняется там, где не должно, а также чтобы сохранить функциональную чистоту редьюсеров
  • redux-thunk — используется когда нужно, чтобы действия (actions) имели какой-либо побочный эффект в дополнение к обновлению состояния приложения. Например, вызов REST API, или установка маршрутов (routes), или даже вызов других действий.
  • reselect — используется для создания составных, лениво исполняемых отображений. Например для конкретного компонента вам может потребоваться:
  • 1. вставить только определенную часть глобального состояния, а не полностью
  • 2. вставить дополнительные производные данные, например итого или результаты валидации данных, не сохраняя все это в состоянии

Не обязательно использовать все это с первого дня. Я советую применить Redux и Immutable.js как только у вас появится какое-нибудь состояние, reselect — когда у вас появятся производные данные, и redux-thunk — когда у вас появится маршрутизация или асинхронные действия. Лучше начать их использовать раньше, чем позже — это избавит вас от лишней работы для внедрения их в дальнейшем.

*В зависимости от того, кого вы спросите, Redux может быть или не быть “настоящей” реализацией Flux. Лично я считаю, что он достаточно хорошо соответствует ключевым идеям, чтобы называться Flux-фреймворком, но, как бы то ни было, это все вопрос терминологии.

6. Всегда используйте propTypes

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

В разработческом окружении (не на боевом сервере) React будет писать в лог информацию об ошибках, если какой-либо компонент не получил требуемый prop , или получил, но данные оказались не того типа, который ожидался. В этом есть следующие преимущества:

  • это может отловить ошибку на ранней стадии, предотвращая глупые ошибки
  • если вы воспользуетесь isRequired , то вам не придется так часто делать проверку на undefined или null
  • это также выполняет роль документации, освобождая читателя от необходимости поиска по всему компоненту, с целью понять какие props ему нужны

Этот список выглядит так, будто составлен апологетом языков со статической типизацией. Лично я предпочитаю динамическую типизацию, потому что она делает разработку более легкой и быстрой. Но я пришел к тому, что propTypes дает типобезопасность, не добавляя излишнюю сложность. Честно говоря, я не вижу причины не использовать propTypes всегда, когда это возможно.

Еще один совет — сделайте так, чтобы тесты падали при любых ошибках, связанных с propTypes . Вот грубоватое, но рабочее решение:

7. Используйте поверхностный рендеринг

Тестирование React-компонентов все еще коварная тема. Не потому что это сложно, а потому что это все еще развивающаяся область, и ни один отдельный подход еще не признан однозначно лучшим. На данный момент, моя палочка-выручалочка это использование поверхностного рендеринга (shallow rendering) и проверка props .

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

Топ-пост этого месяца:  Использование dns-prefetch в Wordpress

Когда я тестирую компоненты, чаще всего я пишу следующие виды юнит-тестов:

Логика рендеринга

Представим компонент, который должен отображать изображение или иконку, в зависимости от условий:

Мы можем протестировать его следующим образом:

Проще простого! Стоит обратить внимание, что API для поверхностного рендеринга немного сложнее, чем показано в этом примере. Функция shallowRender это наша самописная вспомогательная обертка вокруг реального API, облегчающая его использование.

Возвращаясь к нашему компоненту ListOfNumbers , вот так мы можем протестировать, что обход массива происходит корректно:

Преобразование свойств

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

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

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

Взаимодействие с пользователем

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

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

Это достаточно упрощенный пример, но, надеюсь, вы поняли идею.

Интеграционное тестирование

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

  1. Рендерите все дерево компонентов (вместо поверхностного рендеринга)
  2. Работайте непосредственно с DOM (используя React TestUtils или jQuery), чтобы определить элементы, которые вас непосредственно интересуют, и затем:
  3. Проверяйте их HTML атрибуты, содержимое или…
  4. Эмулируйте события DOM и затем проверяйте побочные эффекты (изменения в DOM или в маршрутах, вызовы AJAX и т.п.)

По поводу TDD

Вообще, я не использую TDD при написании React-компонентов. Во время работы над компонентом, я часто “перетряхиваю” его структуру, пытаясь написать как можно более простые HTML и CSS, которые выглядят правильно в любом из поддерживаемых мной браузеров. А поскольку мой подход к модульному тестированию компонентов, как правило, завязан на их структуру, то мне придется постоянно чинить тесты, что будет пустой тратой времени.

Другая причина это необходимость в том, чтобы компоненты были очень простыми, что сведет на нет все преимущества подхода test-first. Вся сложная логика и преобразования выведены в редьюсеры и создатели действий, где я уже по полной пожинаю плоды TDD.

В этом разделе я говорил только о тестировании компонентов, поскольку для тестирования остальной части Redux-приложений не требуется какая-либо специфическая информация. Как у фреймворка, у Redux совсем немного “магии”, скрытой под капотом. И я считаю, это сокращает потребность в каком-либо чрезмерном подготовительном процессе к тестированию. Все что есть, это всего лишь давно знакомые, простые функции (много из них чистые), что является настоящим глотком свежего воздуха, когда дело доходит до тестирования.

8. Используйте JSX, ES6, Babel, Webpack и NPM (или Yarn)

Специфичная для React вещь здесь только одна — JSX. Для меня это просто более наглядная и понятная замена вызову React.createElement . Единственный недостаток здесь это небольшое усложнение в процессе сборки, что легко решается с помощью Babel.

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

В довершение ко всему, мы используем Webpack для сборки нашего кода, и NPM для управления зависимостями. И теперь мы полностью соответствуем новомодным трендам в JavaScript 🙂

(Прим. пер.: сейчас рекомендуется использовать yarn вместо NPM, по ряду причин )

9. Используйте dev tools для React и Redux

Говоря о сопутствующем инструментарии, у React и Redux есть достаточно крутые инструменты разработчика. React dev tools дает возможность проинспектировать отрендеренное дерево компонентов, что чрезвычайно полезно, когда необходимо увидеть что же в конечном итоге получилось в браузере. Redux dev tools гораздо более выразительны и позволяют увидеть каждое произошедшее действие, изменение состояния, которое оно вызвало, и даже дает возможность перемещаться назад во времени! Вы можете добавить его как dev-зависимость, или как браузерное расширение.

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

10. Бонус от переводчика. Используйте React Create App

react-create-app это утилита командной строки, которая дает возможность создать пустое приложение с базовой структурой директорий, встроенным и настроенным Webpack, Babel и Eslint, со всеми зависимостями. Вам остается только запустить его командой yarn start и сфокусироваться на коде и бизнес-логике вашего приложения, не погружаясь в дебри настройки окружения. Если же вдруг потребуется изменить стандартную конфигурацию, то и такая возможность есть (команда eject ).

Заключение

Надеюсь, эти советы дадут вам преимущество в изучении React, и помогут избежать некоторые наиболее распространенные ошибки. Если вам понравилась эта статься, то можете зафолловить меня в Твиттере, или подписаться на мой RSS feed.

digitech

[Из песочницы] Самые распространенные ошибки в вашем React коде, которые вы (возможно) делаете

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

Весь код написан в ES6 стиле, поэтому, что бы повторить его вам нужно использовать Babel в вашем проекте (а еще есть такие кто его не использует?).

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

Если вам интересно, то добро пожаловать под кат.

10 ошибок, которые часто допускают новички JavaScript

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

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

1. Пропуск фигурных скобок

Одна из ошибок, которую часто допускают новички JavaScript — пропуск фигурных скобок после операторов типа if, else,while и for . Хотя это не запрещается, вы должны быть очень осторожны, потому что это может стать причиной скрытой проблемы и позже привести к ошибке.

Смотрите пример, приведенный ниже:

Хотя вызов fail() имеет отступ и, кажется, будто он принадлежит оператору if , это не так. Он вызывается всегда. Так что это полезная практика окружать все блоки кода фигурными скобками, даже если в них присутствует только один оператор.

2. Отсутствие точек с запятой

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

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

Так как в строке 3 отсутствует точка с запятой, анализатор предполагает, что открывающаяся скобка в строке 5 является попыткой доступа к свойству, используя синтаксис массива аксессора (смотри ошибку № 8), а не отдельным массивом, который является не тем, что предполагалось.

Это приводит к ошибке. Исправить это просто — всегда вставляйте точку с запятой.

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

3. Непонимание приведений типа


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

Это делает JavaScript гораздо более простым, чем, скажем, C# или Java . Но это таит в себе потенциальную опасность ошибок, которые в других языках выявляются на этапе компиляции.

Проблема может быть легко исправлена с применением parseInt(textBox.value, 10) , чтобы перевести строку в число перед добавлением к ней 10.

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

Чтобы не допустить преобразования типа при сравнении переменных в операторе if , вы можете использовать проверку строгого равенства ( === ).

4. Забытые var

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

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

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

Когда анализатор достигает строки 4, он автоматически добавит точку с запятой, а затем интерпретирует объявления c и d в строке 5, как глобальные.

Это приведет к изменению значения другой переменной c. Больше о подводных камнях JavaScript здесь .

5. Арифметические операции с плавающей точкой

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

Чтобы обойти эту проблему, вы не должны использовать десятичные числа, если вам нужна абсолютная точность — используйте целые числа, или если вам нужно работать с денежными единицами, используйте библиотеку типа bignumber.js .

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

Когда программисты Java и C # начинают писать на JavaScript, они часто предпочитают создавать объекты с использованием конструкторов: new Array(), new Object(), new String() .

Хотя они прекрасно поддерживаются, рекомендуется использовать оригинальные обозначения: [], <>, «» , так как конструкторы имеют свои особенности:

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

7. Непонимание того, как разделяются диапазоны

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

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

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

8. Использование Eval

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

Код внутри eval — это строка. Отладочные сообщения, связанные с Eval-блоками непонятны, и вам придется поломать голову, чтобы правильно расставить одинарные и двойные кавычки.

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

9. Непонимание асинхронного кода

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

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

Вот пример, в котором я использую сервис FreeGeoIP для определения вашего местоположения по IP-адресу:

Несмотря на то, что console.log располагается после вызова функции load() , на самом деле он выполняется перед определением данных.

10. Злоупотребление отслеживанием событий

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

Новичок в этом случае может сделать следующее (используя JQuery ):

Что-то, очевидно, не так. В идеале, вы должны отслеживать события только один раз, как задано для изменения события чекбокса.

Повторяющийся вызов button.on(‘click’ ..) приводит к повторяющемуся отслеживанию события, которое никогда не удаляется.

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

Заключение

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

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

Данная публикация представляет собой перевод статьи « 10 Mistakes That JavaScript Beginners Often Make » , подготовленной дружной командой проекта Интернет-технологии.ру

9 принципов, которые должен знать новичок в React.js

Автор статьи: Cam Jackson . Оригинал статьи здесь . От переводчика: статья не лишена спорных или субъективных моментов, но, все же, большинство изложенных принципов достаточно полезны.

Я использую React.js с 2015 года. По большому счету, это не такой уж и большой срок, но в постоянно меняющемся мире JavaScript, этого достаточно, чтобы мнить себя умудренным старцем. Недавно я помог нескольким людям советами по началу работы с React, поэтому я подумал, что было бы неплохо опубликовать некоторые из них здесь, чтобы больше людей их увидели. Это все — принципы, которые я хотел бы знать, когда я начинал изучать React, или принципы, которые действительно помогли мне разобраться в React’e.

Я предполагаю, что вы уже знаете самые основы. Но если слова component , props , или state вам не знакомы, то вам лучше бы сначала прочитать официальные Hello World или Руководство. Также, я буду использовать JSX, потому что он предоставляет гораздо более краткий и выразительный синтаксис для написания компонентов.

1. Это просто библиотека отображения

Давайте сначала разберемся с основами. React это не очередной MVC-фреймворк или какой-либо другой фреймворк. Это всего лишь библиотека для рендеринга ваших отображений (views). Если вы пришли из мира MVC, то вам нужно осознать, что React это буква ‘V’ в этой аббревиатуре, и вы должны поискать где-нибудь в другом месте, когда дело доходит до ‘M’ и ‘C’, иначе в результате вы получите кучу дурно пахнущего React-кода. Подробнее об этом далее.

2. Делайте небольшие компоненты

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

Компонент представляет собой с двумя

для каждого элемента массива. Эта последняя часть, выдающая

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

3. Пишите функциональные компоненты

Ранее было два способа объявления React-компонента, первым был — React.createClass() :

Затем появился способ, использующий классы ES6:

React 0.14 представил новый синтаксис — объявление компонентов как функций от props:

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

Этот класс не такой плохой, как вообще могут быть классы. Мы уже выделили пару методов из метода render() , разделив его на небольшие блоки с понятными названиями. Задача вывода кратких версий последних записей блога решена. Теперь давайте перепишем тот же самый код, используя функциональный синтаксис:

Большая часть кода не изменилась, только теперь у нас голые функции вместо методов класса. Тем не менее, для меня это большая разница. Когда компонент разбит на функции, мне субъективно проще поймать тот момент, когда этот компонент уже пора разбить на более мелкие компоненты. Таким образом, “функциональный” синтаксис помогает мне следовать пункту №2.

В будущем, также, планируются оптимизации в React, которые сделают функциональные компоненты более эффективными, чем классовые. ( Update: оказалось что изменения в производительности функциональных компонентов сложнее, чем я думал. Я все еще рекомендую использовать функциональные компоненты, но если вас сильно тревожит производительность, то вам следует прочитать и понять это и это, и решить что работает лучше в вашем случае.)

Важно отметить, что функциональные компоненты имеют несколько “ограничений”, которые я бы, скорее, назвал их сильными сторонами. Во-первых, функциональному компоненту нельзя присвоить атрибут ref (подробнее о нем здесь). Хотя он и является удобным способом для взаимодействия с дочерними компонентами из родительского, но, по моим ощущениям, это Неправильный Способ Разработки на React. ref -атрибуты поощряют очень императивный и почти jquery-подобный подход к написанию компонентов, уводя нас в сторону от философии функциональности и однонаправленности потока данных, ради которой мы и выбираем React.

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

4. Создавайте компоненты, не имеющие состояние (stateless)

Должен сказать, что на данный момент самая большая боль, которую я ощутил создавая приложения на React, была вызвана компонентами, у которых было слишком много состояния (state).

Наличие состояния затрудняет тестирование компонентов

Нет ничего проще для тестирования, чем чистые функции. Так зачем же нам лишать себя возможности делать компоненты в виде чистых функций, добавляя к ним состояние? Во время тестирования компонентов с состоянием, нам приходится приводить компоненты к определенному состоянию, чтобы затем протестировать их поведение. Нам, также, приходится возиться со всем разнообразием комбинаций состояния (которое компонент может изменить в любой момент) и входных атрибутов ( props , которые компонент вообще не контролирует), и выяснять которые из них тестировать и как. А когда компоненты выполнены в виде простых функций от входных данных — тестировать намного легче. (Подробнее о тестировании ниже).

Наличие состояния затрудняет понимание работы компонента

Когда читаешь код компонента со сложным и развесистым состоянием, то приходится сильнее напрягать голову, чтобы уследить за всем что происходит. Постоянно возникают вопросы из разряда: “Это состояние уже инициализировано?”, “Что будет, если я поменяю состояние в этом месте?”, “Возникает ли здесь race condition?”. Просмотр компонентов, имеющих состояние, с целью понять их поведение, становится очень болезненным.

Наличие состояния слишком легко позволяет вставить в компонент бизнес-логику

На самом деле, просмотр компонентов с целью выявления логики поведения это не то, что мы должны делать. Вспомните, React это библиотека отображения, таким образом логика рендеринга в компоненте это ОК, но бизнес-логика в компоненте — это очень плохо. И когда большая часть состояния приложения уже находится прямо здесь в компоненте и легко доступна с помощью this.state , то возникает большой соблазн добавить сюда же логику вроде подсчетов чего-либо или валидацию, чего не должно быть в компоненте. Возвращаясь к одному из предыдущих пунктов, это сильно затрудняет тестирование — вы не можете протестировать логику рендеринга, без путающейся под ногами бизнес-логики, и наоборот!

Топ-пост этого месяца:  Профессия менеджер проекта обучение и дальнейшие перспективы работы по специальности

Наличие состояния затрудняет обмен информацией с другими частями приложения

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

Конечно, иногда имеет смысл оставлять определенную часть состояния приложения “на совести” конкретного компонента. В таком случае, вполне можно использовать this.setState . Это допустимая и легальная возможность API React-компонентов, и я не хочу чтобы сложилось впечатление, что это нужно запретить. Например, когда пользователь вводит текст в поле, то, скорее всего, всему приложению не нужно знать о каждом нажатии клавиши. Во время этого, компонент input может менять свое промежуточное состояние до тех пор, пока не потеряет фокус, после чего итоговый текст отправится наружу и станет частью состояния, хранящегося где-нибудь в другом месте. Этот сценарий недавно упомянул мой коллега, и я считаю, что это хороший пример.

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

5. Используйте Redux.js

В первом пункте я сказал, что React это только отображение. Тогда возникает очевидный вопрос “Где должны храниться состояние и логика?”. Я рад, что вы спросили!

Возможно вы уже слышали о Flux, который представляет собой стиль/шаблон/архитектуру для создания web-приложений, в основном использующих для рендеринга React. Существует несколько фреймворков, воплощающих идеи Flux, но я без сомнения могу порекомендовать Redux.js *.

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

  1. Компоненты получают функции обратного вызова, как props , которые они вызывают, когда возникают события UI
  2. Эти функции обратного вызова создают и возвращают действия, основываясь на информации о событии
  3. Редьюсеры обрабатывают действия, вычисляя новое состояние
  4. Новое состояние всего приложения отправляется в единое хранилище
  5. Компоненты получают новое состояние через props и перерисовывают себя там, где это необходимо

Большая часть перечисленных концепций не является уникальной для Redux, но Redux реализует их просто и без излишеств, с помощью минимального API. Перенося приличного размера проект с Alt.js на Redux, я обнаружил несколько преимуществ последнего. Вот самые значительные из них:

  • Редьюсеры это чистые функции, все что они делают это oldState + action = newState . Каждый редьюсер вычисляет отдельный кусок состояния. Все эти куски, впоследствии, объединяются вместе, формируя целое приложение. Это значительно упрощает тестирование бизнес-логики и логики изменения состояния.
  • API меньше, проще и лучше документирован. Я обнаружил, что его концепции гораздо проще и легче изучать, и, следовательно, намного легче разобраться в потоках действий и информации в приложении.
  • Если его использовать так, как рекомендовано, то лишь незначительное число компонентов будет напрямую зависеть от Redux. Все остальные компоненты просто получают состояние и функции обратного вызова через props . Таким образом, компоненты остаются очень простыми и уменьшается завязанность на конкретном фреймворке.

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


  • Immutable.js — немутабельные структуры данных для JavaScript! Используйте их для хранения состояния, чтобы быть уверенным, что оно не меняется там, где не должно, а также чтобы сохранить функциональную чистоту редьюсеров
  • redux-thunk — используется когда нужно, чтобы действия (actions) имели какой-либо побочный эффект в дополнение к обновлению состояния приложения. Например, вызов REST API, или установка маршрутов (routes), или даже вызов других действий.
  • reselect — используется для создания составных, лениво исполняемых отображений. Например для конкретного компонента вам может потребоваться:
  • 1. вставить только определенную часть глобального состояния, а не полностью
  • 2. вставить дополнительные производные данные, например итого или результаты валидации данных, не сохраняя все это в состоянии

Не обязательно использовать все это с первого дня. Я советую применить Redux и Immutable.js как только у вас появится какое-нибудь состояние, reselect — когда у вас появятся производные данные, и redux-thunk — когда у вас появится маршрутизация или асинхронные действия. Лучше начать их использовать раньше, чем позже — это избавит вас от лишней работы для внедрения их в дальнейшем.

*В зависимости от того, кого вы спросите, Redux может быть или не быть “настоящей” реализацией Flux. Лично я считаю, что он достаточно хорошо соответствует ключевым идеям, чтобы называться Flux-фреймворком, но, как бы то ни было, это все вопрос терминологии.

6. Всегда используйте propTypes

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

В разработческом окружении (не на боевом сервере) React будет писать в лог информацию об ошибках, если какой-либо компонент не получил требуемый prop , или получил, но данные оказались не того типа, который ожидался. В этом есть следующие преимущества:

  • это может отловить ошибку на ранней стадии, предотвращая глупые ошибки
  • если вы воспользуетесь isRequired , то вам не придется так часто делать проверку на undefined или null
  • это также выполняет роль документации, освобождая читателя от необходимости поиска по всему компоненту, с целью понять какие props ему нужны

Этот список выглядит так, будто составлен апологетом языков со статической типизацией. Лично я предпочитаю динамическую типизацию, потому что она делает разработку более легкой и быстрой. Но я пришел к тому, что propTypes дает типобезопасность, не добавляя излишнюю сложность. Честно говоря, я не вижу причины не использовать propTypes всегда, когда это возможно.

Еще один совет — сделайте так, чтобы тесты падали при любых ошибках, связанных с propTypes . Вот грубоватое, но рабочее решение:

7. Используйте поверхностный рендеринг

Тестирование React-компонентов все еще коварная тема. Не потому что это сложно, а потому что это все еще развивающаяся область, и ни один отдельный подход еще не признан однозначно лучшим. На данный момент, моя палочка-выручалочка это использование поверхностного рендеринга (shallow rendering) и проверка props .

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

Когда я тестирую компоненты, чаще всего я пишу следующие виды юнит-тестов:

Логика рендеринга

Представим компонент, который должен отображать изображение или иконку, в зависимости от условий:

Мы можем протестировать его следующим образом:

Проще простого! Стоит обратить внимание, что API для поверхностного рендеринга немного сложнее, чем показано в этом примере. Функция shallowRender это наша самописная вспомогательная обертка вокруг реального API, облегчающая его использование.

Возвращаясь к нашему компоненту ListOfNumbers , вот так мы можем протестировать, что обход массива происходит корректно:

Преобразование свойств

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

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

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

Взаимодействие с пользователем

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

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

Это достаточно упрощенный пример, но, надеюсь, вы поняли идею.

Интеграционное тестирование

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

  1. Рендерите все дерево компонентов (вместо поверхностного рендеринга)
  2. Работайте непосредственно с DOM (используя React TestUtils или jQuery), чтобы определить элементы, которые вас непосредственно интересуют, и затем:
  3. Проверяйте их HTML атрибуты, содержимое или…
  4. Эмулируйте события DOM и затем проверяйте побочные эффекты (изменения в DOM или в маршрутах, вызовы AJAX и т.п.)

По поводу TDD

Вообще, я не использую TDD при написании React-компонентов. Во время работы над компонентом, я часто “перетряхиваю” его структуру, пытаясь написать как можно более простые HTML и CSS, которые выглядят правильно в любом из поддерживаемых мной браузеров. А поскольку мой подход к модульному тестированию компонентов, как правило, завязан на их структуру, то мне придется постоянно чинить тесты, что будет пустой тратой времени.

Другая причина это необходимость в том, чтобы компоненты были очень простыми, что сведет на нет все преимущества подхода test-first. Вся сложная логика и преобразования выведены в редьюсеры и создатели действий, где я уже по полной пожинаю плоды TDD.

В этом разделе я говорил только о тестировании компонентов, поскольку для тестирования остальной части Redux-приложений не требуется какая-либо специфическая информация. Как у фреймворка, у Redux совсем немного “магии”, скрытой под капотом. И я считаю, это сокращает потребность в каком-либо чрезмерном подготовительном процессе к тестированию. Все что есть, это всего лишь давно знакомые, простые функции (много из них чистые), что является настоящим глотком свежего воздуха, когда дело доходит до тестирования.

8. Используйте JSX, ES6, Babel, Webpack и NPM (или Yarn)

Специфичная для React вещь здесь только одна — JSX. Для меня это просто более наглядная и понятная замена вызову React.createElement . Единственный недостаток здесь это небольшое усложнение в процессе сборки, что легко решается с помощью Babel.

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

В довершение ко всему, мы используем Webpack для сборки нашего кода, и NPM для управления зависимостями. И теперь мы полностью соответствуем новомодным трендам в JavaScript 🙂

(Прим. пер.: сейчас рекомендуется использовать yarn вместо NPM, по ряду причин )

9. Используйте dev tools для React и Redux

Говоря о сопутствующем инструментарии, у React и Redux есть достаточно крутые инструменты разработчика. React dev tools дает возможность проинспектировать отрендеренное дерево компонентов, что чрезвычайно полезно, когда необходимо увидеть что же в конечном итоге получилось в браузере. Redux dev tools гораздо более выразительны и позволяют увидеть каждое произошедшее действие, изменение состояния, которое оно вызвало, и даже дает возможность перемещаться назад во времени! Вы можете добавить его как dev-зависимость, или как браузерное расширение.

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

10. Бонус от переводчика. Используйте React Create App

react-create-app это утилита командной строки, которая дает возможность создать пустое приложение с базовой структурой директорий, встроенным и настроенным Webpack, Babel и Eslint, со всеми зависимостями. Вам остается только запустить его командой yarn start и сфокусироваться на коде и бизнес-логике вашего приложения, не погружаясь в дебри настройки окружения. Если же вдруг потребуется изменить стандартную конфигурацию, то и такая возможность есть (команда eject ).

Заключение

Надеюсь, эти советы дадут вам преимущество в изучении React, и помогут избежать некоторые наиболее распространенные ошибки. Если вам понравилась эта статься, то можете зафолловить меня в Твиттере, или подписаться на мой RSS feed.

10 самых распространенных ошибок начинающих программистов

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

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

1. Выбор платформы и языка программирования

Все начинающие программисты очень долго думают над тем, куда же им податься и какую сферу программирования осваивать. И чаще всего они идут на форумы, где, задав вопрос “Какой язык выбрать” или “В какую сферу пойти?”, выслушивают (или, точнее сказать, читают) массу противоречащих друг другу советов от разных пользователей. Ведь сколько людей, столько и мнений, поэтому зачастую под такими вопросами начинаются настоящие холивары о том, какой же язык программирования круче и перспективнее.

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

Еще один более трудоемкий способ – это ходить на собеседования. Там вы не только сможете понять, нужны ли вы вообще хоть кому-нибудь с тем объемом знаний и навыков, которыми вы обладаете на данный момент. А еще вы поймете, какие требования есть у работодателей.

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

2. Слишком много сомнений

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

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

3. Слишком высокое самомнение

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

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

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

4. Не знать английский

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

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

5. Слишком много комментариев

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

Но вот что вам не стоит делать, так это оставлять комментарии вроде этого: “score += 5; // добавляет 5”. Это очевидно, и нет нужды еще раз писать об этом в комментарии. Конечно, комментировать каждую линию – это отличное упражнение для вашей первой программы. Но это не то, к чему вы должны привыкать.

6. Не доучиваться до конца

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

7. Учить один язык за другим

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

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

8. Пренебрегать дебаггерами

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

9. Не делать бэкапы своей работы

Вы должны вычеркнуть из своего словаря фразу “На это было потрачено Х часов работы!” Существует масса отличных инструментов, которые автоматически делают бэкапы и помещают их в облако, например, поэтому любые проблемы, будь то пожар или “синий экран”, не могут свести на нет все ваши труды.

10. Писать код без плана

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

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

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

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

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

Добавить комментарий