Разбор слова сделать по составу: Страница не найдена

admin

Содержание

Разбор слов по составу

Разбор слова по составу

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

Виды морфем

В русском языке используются следующие морфемы:

— Корень. В нем заключается значение самого слова. Слова, у которых есть общий корень, считаются однокоренными. Иногда слово может иметь два и даже три корня.
— Суффикс. Обычно идет после корня и служит инструментом для образования других слов. К примеру, «гриб» и «грибник». В слове может быть несколько суффиксов, а может не быть совсем.
— Приставка. Находится перед корнем. Может отсутствовать.
— Окончание. Та часть слова, которая изменяется при склонении или спряжении.
— Основа. Часть слова, к которой относятся все морфемы, кроме окончания.

Важность морфемного разбора

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

Пример

В качестве примера можно взять два слова: «чёрный» и «червячок». Почему в первом случае на месте ударной гласной мы пишем «ё», а не «о», как в слове «червячок»? Нужно вспомнить правило написания букв «ё», «е», «о» после шипящих, стоящих в корне слова. Если возможно поменять форму слова либо подобрать родственное ему так, чтобы «ё» чередовалась с «е», тогда следует ставить букву «ё» (чёрный — чернеть). Если чередование отсутствует, тогда ставится буква «о» (например, чокаться, шорты).

В случае же со словом «червячок» «-ок-» — это суффикс. Правило заключается в том, что в суффиксах, если стоящая после шипящих букв гласная находится под ударением, всегда пишется «о» (зрачок, снежок), в безударном случае — «е» (платочек, кармашек).

Как разобрать слово по составу

Для помощи начинающим существуют морфемно-орфографические словари. Можно выделить книги таких авторов, как Тихонов А.Н., Ожегов С.И., Рацибурская Л.В.

В любом слове непременно должны присутствовать корень и основа. Остальных морфем может и не быть. Иногда слово целиком может состоять из корня (или основы): «гриб», «чай» и т.д.

Этапы морфемного анализа

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

— Сначала нужно определить часть речи, задав вопрос к слову. Для прилагательного это будет вопрос «какой?», для существительного — «что?» или «кто?».
— Затем нужно выделить окончание. Чтобы его найти, слово нужно просклонять по падежам, если часть речи это позволяет. Например, наречие изменить никак нельзя, поэтому у него не будет окончания.
— Далее нужно выделить основу у слова. Все, кроме окончания, — основа.
— Потом следует определить корень, подобрав родственные однокоренные слова.
— Определяется приставка, а потом суффиксы (при их наличии).

Особенности разбора

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

Памятка- алгоритм разбора слова по составу (морфемный разбор). | Материал по русскому языку (4 класс) по теме:

Порядок разбора

Особенности выделения морфемы

Примеры

  1. Выделить

окончание

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

Следует помнить, что у неизменяемых слов (н-р: несклоняемые имена существительные, наречия) нельзя выделить окончание. Затем изменяем форму слова ( у сущ.: изменяем число, падеж, у прил.: род, число, падеж.; у глаг.: время, число, род или лицо). Помни, что у неопределенной формы глагола есть показатель ть, ти–(суффикс/окончание), договорились выделять  . Изменяемая часть слова-  Если окончания в данной форме нет, но оно может проявиться- это нулевое окончание.

Лес, лес-а, лес-у…

Морск-ой, морск-ая, морск-ие, морск-ого;

Гулял, гулял-а, гулял-и…

  1. Выделить

основу

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

Морск-ой, лесник-

  1. Выделить

корень

Чтобы определить в слове корень, подбираем родственные (или однокоренные слова). Их общая часть- это .

Лесник-лесной, лесовик- лес-лесок

 Корень ЛЕС

  1. Выделить

приставку

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

Приставки служат для образования новых слов.

Расчёска образовалось от чесать, рас- можно заменить: при-ческа, кроме того, рас- употребляется в других словах: рас-пределить, рас-пил и т.д

  1. Выделить

суффикс

(Если есть), стоит после корня, их может быть несколько, приведи примеры других слов с тем же суффиксом.

Например слово «грузовик», корень груз, оставшуюся часть пробуем разделить: грузов-(ой)/-ик, -ик-это суффикс, он употребляется в других словах: мост-ик, двор-ик; -ов- тоже суффикс, так в словах: сосн-ов-ый, порт-ов-ый

морфемный разбор слова, схема, таблица и образец

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

…

Вконтакте

Facebook

Twitter

Google+

Мой мир

Схема морфологического разбора глагола

Стандартный план исследования слова прост: нужно определить часть речи, найти начальную форму слова и описать последовательно его постоянные и непостоянные признаки. В последнюю очередь дается описание роли слова в предложении (если слово не изъяли из контекста).

Это интересно: исконно русские слова — примеры и история происхождения.

Определение части речи

Глаголы отвечают на вопросы: Что делать? и Что сделать? Более точно вопрос задается с учетом словоизменения.

Определение инфинитива

Инфинитив — это начальная или, как говорили в школе, неопределенная форма глагола. Собственно, именно она и отвечает на вопрос: Что делать/сделать?

Описание постоянных признаков

Постоянными являются те признаки, которые слово сохраняет при словоизменении (в данном случае спрягаясь). К ним относятся:

  • Вид. Бывает совершенным и несовершенным. Вид характеризует результативность действия, перфектность. Носителю русского языка не составит труда определить вид, задав вопрос. Глаголы совершенного вида отвечают на вопрос Что сделать?, несовершенного — Что делать? Изучающему русский язык сложнее: придется выполнить морфемный разбор слова и ориентироваться в определении вида прежде всего на морфемный состав. Ну и выучить список слов, которые не укладываются в правила словообразования, например: лечь, сесть, бросить и др. Кроме того, существуют двухвидовые глаголы, например, ранить, жениться и т. д., вид которых можно определить только из контекста, то есть по лексическому значению в предложении.
  • Возвратность. Возвратностью называется действие, обращенное на себя. Такие глаголы имеют на конце постпозитивный суффикс -ся.
  • Переходность. Характеризует возможность находиться в связи с существительным в винительном падеже без предлога (управлять им). Для определения переходности нужно задать после глагола вопрос Кого? Что?
  • Спряжение. Тип спряжения определяется по окончанию инфинитива (точнее, по суффиксу и окончанию) для большинства глаголов русского языка. Так, к первому относятся глаголы заканчивающиеся на -ать, -уть, -еть, -ть, -ять, ко второму — -ить и -ыть. Из этого правила есть исключения: стелить и брить относятся к первому спряжению, так как личные окончания у них формируются по образцу первого. А видеть, слышать, ненавидеть, зависеть, смотреть, вертеть и еще с пару десятков (часть из них проходили в школе в виде стишка, остальные остались вне учебника) относятся ко второму. Помимо этого, в русском языке существуют глаголы нерегулярного спряжения, личные окончания которых бывают как первого, так и второго типа (бежать, чтить, брезжить), а также неправильного, или особого, парадигма образования личных форм которых имеет еще древнерусскую модель или отсутствует. К последним относятся есть, дать, быть, создать и производные от них.

Нужно знать: Фонетический разбор слова.

Непостоянные признаки

К ним относятся признаки, которые глагол приобретает при словоизменении.

  • Наклонение. В русском языке выделяют три наклонения: индикатив (изъявительное), субъюнктив (сослагательное, или условное) и императив (повелительное). Вторая форма всегда составная, а третья может быть как простой, так и составной.
  • Время. Определяется в изъявительном наклонении. В русском языке существуют три временных формы (настоящее, прошедшее и будущее), причем одна из них состоит из двух видовременных: будущее совершенное (простое) и будущее сложное (аналитическое).
  • Число.
  • Лицо (не определяется в прошедшем времени и в условном наклонении).
  • Род (определяется только в прошедшем времени и в сослагательном наклонении).

Нужно знать: Морфология русского языка, что изучает наука.

Глагол в предложении

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

Роль морфемного разбора слова

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

Это интересно: баловаться — ударение на каком слоге ставить?

Вот несколько примеров:

  • Бить относится не ко второму спряжению, а к первому, так как би- — это корень слова, а -ть — флексия (окончание).
  • Вынуть не имеет корня вообще. Есть префикс (приставка) вы-, суффикс -ну- и флексия -ть. При словообразовании проявляется корень -им-. Сравните: иметь, принять, вынимать.
  • Быть относится к глаголам неправильного спряжения (наверное, нет такого индоевропейского языка, где он правильный) с корнем бы- и окончанием -ть. Все личные формы настоящего времени, в том числе и устаревшие, образовывались не от корня бы-, а супплетивно, то есть от другой основы (некоторые полагают, что от нее произошел глагол стать), которая исчезла еще в дописьменную эпоху: я есмь; ты еси; он, она, оно есть; мы есмы; вы есте; они суть.
  • Выть, вить, дуть имеют окончание -ть, остальное относится к корню.
  • Брить имеет корень бр-, суффикс -и- и окончание-ть. Что не мешает ему быть исключением из правила.

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

Примеры морфологического разбора

Для удобства приведем несколько примеров в таблице.

И в ус не дует. (поговорка)Отсель грозить мы будем шведу. (А. Пушкин)Откуда есть пошла Русская земля. (из летописи)Взялся за гуж, не говори, что не дюж. (пословица)Храни меня, мой талисман. (А. Пушкин)
ВопросЧто делает?Что будем делать?Что сделала?*Что сделал?Что делай?
ИнфинитивДутьГрозитьБытьВзятьсяХранить
Постоянные признаки: видНесовершенныйНесовершенныйНесовершенныйСовершенныйНесовершенный
возвратностьНевозвратныйНевозвратныйНевозвратныйВозвратныйНевозвратный
переходностьПереходный (дуть что?)НепереходныйНепереходныйНепереходныйПереходный
спряжение12Неправильное12
Непостоянные признаки: наклонениеИзъявительноеИзъявительноеИзъявительноеИзъявительноеПовелительное
времяНастоящееБудущее аналитическоеНастоящее (прошедшее)*Прошедшее
числоЕдинственноеМножественное**ЕдинственноеЕдинственноеЕдинственное
лицо31322
родЖ*М
Роль в предложенииСказуемое простоеЧасть составного сказуемогоЧасть составного сказуемогоСказуемое простоеСказуемое простое
Морфемный разборду-етгроз-и-тьес-тьв-зя-л-сяхран-и

Примечания.

* — глагол быть представлен как часть составного прошедшего времени древнерусского языка — перфекта. Он употреблялся в форме настоящего времени соответствующего лица в паре с «эльным» причастием прошедшего времени, которое со временем и стало современным прошедшим временем, вытеснив все остальные формы (аорист, имперфект и плюсквамперфект). Грамматически перфект представлял из себя состояние, явившееся результатом недавно прошедшего действия. Поэтому вопрос задан не к быть, а ко всей форме есть пошла. Род указан по слову пошла.

Это интересно: «семи пядей во лбу» — значение фразеологизма.

** — разбор относится к слову грозить, но вопрос задан ко всей конструкции.

Образец разбора глагола

Приведем пример классического разбора (как в школе) на примере глагола разбирают.

I. Что делают? Разбирают.

II. Инфинитив — разбирать.

III. Постоянные признаки:

  • несовершенный вид;
  • невозвратный;
  • переходный;
  • первое спряжение.

IV. Непостоянные признаки:

  • изъявительное наклонение;
  • настоящее время;
  • третье лицо;
  • множественное число.

V. Скорее всего, в предложении будет сказуемым.

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

как сделать первые поделки своими руками, какие стили применить и какую бумагу выбрать – подробный разбор на TEA.ru

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

Что такое скрапбукинг и при чём здесь Марк Твен

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

Первыми скрап-работами считаются обычные рукописные дневники с памятными заметками, цитатами, стихами и зарисовками, созданные еще в XV веке в Европе. Конечно, ни о каких фотографиях тогда и речи не было – их попросту не изобрели. Однако сама идея заполнения страниц различными ценными кусочками информации оказалась востребованной и, незаметно трансформируясь, начала свой путь через века до наших дней.

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

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

Но нам, конечно, и такой формат кажется далеким от современного. Когда же хобби приобрело нынешние черты? У этого события есть точная дата – 1980 год. Именно тогда американка Мэрилин Кристенсен представила на Всемирной конференции документоведения в Солт-Лейк-Сити свои 50 томов скрап-творчества, посвященного ее семье. Спасибо тебе, Мэрилин! Благодаря этой женщине Америку захлестнула мода оформлять личные фотографии записями и украшать их. А потом скрапбукинг стал популярен повсеместно.

Что можно сделать в стиле скрапбукинга

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

Альбомы

Это самое популярное (хоть и самое сложное) направление. Для того чтобы изготовить целый альбом «с нуля», нужно иметь довольно много инструментов, свободного времени и усидчивости, а также владеть несколькими видами оформительских приемов.

Блокноты

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

Открытки

Упрощенная версия скрап-деятельности. Может быть разминкой перед большой работой или вполне самодостаточным делом. Для создания открыток нужно меньше времени, инструментов и усилий.

Другие идеи для скрапбукинга

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

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

Что нужно для скрапбукинга: список покупок для начинающих

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

Материалы

Бумага – основа и главный материал. Когда-то американские домохозяйки использовали любую красивую, но сегодня общепринятым стандартом считается специальная скрап-бумага, не содержащая лигнин (вещество, которое со временем вызывает желтизну бумаги и может плохо повлиять на фотографии). Для разнообразия ее можно дополнять качественной акварельной.

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

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

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

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

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

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

Инструменты

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

  • швейная машинка (для прочного скрепления бумажных, картонных и тканевых элементов),
  • принтер (для распечатки красивых картинок, найденных в интернете),
  • резак (для ровной нарезки бумаги),
  • плоттер (для создания различных резных элементов из бумаги и картона),
  • машинка для вырубки (для той же цели, что и плоттер),
  • фен для эмбоссинга (для создания объемных изображений на бумаге).

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

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

Скрепляющие инструменты могут быть как постоянными, так и расходными материалами:

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

Другие виды инструментов:

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

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

От американской классики до фристайла: какие бывают стили скрапбукинга

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

Американский

Поскольку современный скрапбукинг зародился в Америке, именно американский стиль можно считать базовым и классическим. Ему свойственно обилие ярких деталей декора, которые кажутся немного «детскими», – это упрощенные изображения цветов, «пляшущие» буквы, бабочки, флажки, наклейки, разноцветные пуговицы и красочные фоны с полосками и в горошек. Словом, вспомните моду 80-х, и вам все сразу станет ясно.

Цвета: яркие, радужные, контрастные.

Европейский

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

Цвета: сдержанные, чаще всего в одной гамме (например, синий и голубой или темно-зеленый, светло-зеленый и белый).

«Чисто и просто»

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

Цвета: светлые, чистые, много белого.

Рустик

Этот стиль можно охарактеризовать так – «деревенская простота» или «красота природы». Он допускает использование растительных элементов декорирования (колоски, листья, цветы), грубоватых тканей, деревянных украшений. Должен ощущаться тоже достаточно легким и естественным, даже если в композиции много деталей.

Цвета: природные, спокойные (песочный, травяной, светлые оттенки коричневого).

Шебби-шик

А вот здесь можно как следует разгуляться с пышными цветочными букетами, многоярусными композициями, объемными кружевами, пуговицами и торчащими во все стороны элементами декора. Шебби-шик – один из любимых женских стилей, где можно выгулять свою внутреннюю девочку, позволив ей наслаждаться блестками и жемчугами, сердечками и птичками, гипсовыми рамками и общим впечатлением «взорванного тортика». Чем больше – тем лучше!

Цвета: пастельные, нежные, обязательно присутствие белого.

Гранж

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

Цвета: темные, много черного и коричневого с контрастным ярким акцентом (желтый, оранжевый, белый).

Винтаж

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

Цвета: приглушенные теплые (бордовый, коричневый, темно-зеленый), сепия, ч/б.

Микс-медиа

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

Фристайл

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

Приемы в скрапбукинге, которые помогут вам сотворить шедевр

Создаем наслоения

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

Пишем слова

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

Наносим штампы

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

Режем и рвем

Это целая серия приемов под одним заголовком. Здесь у нас и работа с разнообразными дыроколами (в том числе угла и края), и обработка бумаги фигурными ножницами, и даже обычный разрыв бумаги. Чтобы использовать эту технику, не требуется покупать большой арсенал инструментов, на первых порах достаточно 2–3 маленьких дыроколов, столько же фигурных ножниц, пары дыроколов угла и хотя бы один для края.

Состариваем детали

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

Добавляем блеска и объема

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

Другой способ получить объемные элементы на бумаге – это тиснение. И для него тоже нужны отдельные инструменты – специальные трафареты и палочки. В результате бумага приобретает выпуклый узор.

Шьем

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

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

Советы начинающим скрапбукерам

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

Как сэкономить деньги на покупке материалов

  1. Будьте максимально сдержанны в скрап-магазине. Потому что, как только вы окажетесь среди всей этой невообразимой красоты, вам немедленно захочется купить ВСЕ. Крепитесь и идите четко по списку, который лучше составить заранее. Вам не надо 10 наборов бумаги, не надо 5 новых дыроколов и вот эти чудесные наклейки, возможно, тоже не нужны (если вдуматься и мысленно приложить их к запланированным работам).
  2. Попробуйте разобраться, какие элементы декора вы можете изготовить самостоятельно. Быть может, вам будет выгодней купить машинку для вырубки и трафареты для тиснения, чтобы делать объемные детали в нужном количестве. Или отпороть пуговицы от ненужной старой кофты. Или вырезать красивый рисунок из случайного журнала.
  3. Покупайте ткани и фурнитуру в швейных магазинах. Пуговицы, ленты, шнуры, кружева – все это обычно идет с большой наценкой в скрап-отделах, а в обычном швейном стоит в два раза дешевле.
  4. Помните, что иногда скрап-бумагу вполне можно заменить акварельной, особенно если дело касается открыток и блокнотов, а не фотоальбомов, которые будут храниться много лет.
  5. Чаще проявляйте фантазию и оттачивайте зоркость художника: красивые детали для вашей работы могут найтись где угодно. Используйте страницы старых книг и ежедневников, билеты, упаковочную бумагу (и даже пленку!), обрезки ненужной одежды, пуговицы из тетушкиного шкафа, марки с иностранных конвертов, салфетки из кафе – всякая мелочь может стать частью шедевра.
  6. Даже если вы скромны в средствах, не доводите экономию до абсурда – во всем должно быть равновесие. Не стоит заменять всю скрап-бумагу детским цветным картоном или использовать дешевый клей вместо качественного.

Как научиться приемам скрапбукинга

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

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

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

Как начать зарабатывать с помощью скрапбукинга

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

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

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

Бумага для скрапбукинга: какой она должна быть

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

Как называется бумага для скрапбукинга?

Так и называется – бумага для скрапбукинга, скрап-бумага. Также при желании можно причислить к ней кальку, кардсток (тонкий картон) и бумагу для оригами, но они будут отличаться по качеству и составу.

Обязательно ли покупать скрап-бумагу?

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

Как сделать бумагу для скрапбукинга своими руками?

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

Для чего еще можно использовать бумагу для скрапбукинга?

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

А вы уже опробовали скрапбукинг? Теперь попробуете?

Гдз по русскому языку 7 класс Баранов, Ладыженская Решебник

Недавно Ладыженская, Баранова и Тростенцова написали интересный учебник для 7 класса по русскому языку с полным содержанием решений. Этот учебно-методический комплекс включает также вспомогательные материалы, полюбившуюся рабочую тетрадь и решебник. По приведенным готовым ответам можно проверять правильность выполнения упражнений. Каждый номер подробно объяснен, без ценных комментариев не осталась ни одна орфограмма. Информация изложена кратко и точно, в соответствии с действующими нормативами.

Настоящие ГДЗ по состоянию на 2020 год издает московский холдинг «Просвещение». Эта компания хорошо известная в России благодаря большому количеству учебных изданий, которые она доносит до потребителя.

Почему онлайн-решебник Ладыженской в 7 классе по русскому полюбились детям?

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

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

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

Основные темы ГДЗ по русскому (авторы: Баранов, Ладыженская, Тростенцова, Григорян)?

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

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

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

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

3809 советов

Роман Романов

25 октября 2013

Преамбула.

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

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

Но всё равно получается, что не ценят то, за что почти не платят. С одним из заказчиков (которому письмо ниже) мы уже примерно полгода общаемся, пробуем различные подходы. Всё это происходит по моей инициативе и вялому одобрению с его стороны. Но результат пока нулевой — и интерес начал спадать. Второй месяц не могу получить промоматериалы, обсудить с ним детально мои мысли и задумки.

В итоге я взял месяц тишины: не контачил никак, ну и он тоже на связь не выходил.

Через месяц встретились на бегу, он передал деньги за размещение на месяц — и всё.

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

Хотелось бы услышать комментарии от вас, Илья, что можно было бы убрать/добавить/улучшить на ваш взгляд?

«Привет!

У нас есть проблема. Я буду говорить просто и открыто, как я вижу ситуацию, возможно, я ошибаюсь, и если это так — скажи мне.

Я убрал банер XXXXX с сайта.

Дело в том, что при отсутствии чёткого плана действий и обратной связи, я не могу работать, а пускать всё на самотёк — это ни разу не успешный метод.

Я подозреваю, что если я буду и дальше «молчать в тряпочку», то получится так, что банер провисит ещё один, два, три, четыре месяца безрезультатно, потом тебе надоест выбрасывать деньги на ветер и получится общий вывод: «реклама на сайте — говно». Что не сработало — непонятно, была ли какая то динамика — непонятно, все ли методы испробованы — непонятно. Ну дальше по списку… кто виноват и что делать — тоже непонятно.

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

Если мы всё равно останемся на нуле, значит, мне ещё рано этим всем заниматься, и я переоценил свои силы.

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

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

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

Спасибо.

Роман»

Как правильно разобрать слова по составу / Paulturner-Mitchell.com

Анализ слов по составу (или морфемному — от термина «морфема», обозначающего минимально значимую составляющую слова) — это своего рода лингвистический анализ. Его цель — определить структурный состав лексемы. То есть, чтобы правильно разобрать слово по составу, необходимо найти и выделить все компоненты, из которых построена определенная словоформа. Такой анализ (не путать с морфологическим, когда слово рассматривается с точки зрения принадлежности к определенной части речи) называется морфемическим.

Анализ композиции следует начинать с установления границ каждой морфемы, то есть необходимо правильно определить префикс, корень, суффикс, окончание, основание. Но стоит помнить, что не каждая словоформа обязательно содержит все существующие морфемы: например, «школа» состоит из корня (-school-), суффикса (-n-) и конца (-th). Но, в свою очередь (а это не редкость для современного русского языка), встречаются слова, включающие в себя несколько корней, приставок или суффиксов.Итак, у «парохода» два корня (-pair- и -way-), один суффикс (-n-) и окончание (-th). «Слушатель» состоит из корня (-slush-) и двух суффиксов (-a и -tel-), но у него нет префикса, и окончание этого слова будет нулевым (формально не выражается буквами буквами ).

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

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

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

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

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

Однако необходимо различать слова без окончания и с нулевым окончанием. Как уже было сказано, в нем нет тех словоформ, которые не меняются — герундий, наречий, несклоняемых существительных, прилагательных, стоящих в сравнительной степени.А нулевое окончание — это формально невыделенный показатель грамматического значения изменяемого слова. Примерами формирующих суффиксов могут быть -l-, который используется для образования прошедшего времени глаголов (go-ti + суффикс -l), -e-, с помощью которого производятся степени сравнения для наречий и прилагательных (громче — громче) .

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

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

«лес»

  1. Конец — «ох»
  2. Основа — «лес»
  3. Корень — «лес»
  4. Суффикс «n»

» сотрудники «

  1. Конец -» и «
  2. Основа -» сотрудник «
  3. Корень -» труд «
  4. Префикс -« co »
  5. Суффикс -« ник »

Таким образом, подводя итоги темы «Анализ слов по составу», следует отметить, что только следуя определенному порядку: найти окончание (если оно есть), указать основу, установить, где находится корень (путем выбора корневых слов) , выбрать суффикс, префикс (если есть), можно не допускать ошибок.

Постоянный округ против анализа зависимостей | Баелдунг по информатике

1. Введение

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

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

2. Обзор

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

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

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

Для начала давайте начнем с анализа дерева синтаксического анализа избирательного округа.

2.1. Анализ избирательного округа

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

В английском языке, например, фразы «собака», «компьютер на столе» и «красивый закат» — это все существительные, а «съесть пиццу» и «пойти на пляж» — это глагольные фразы.

Грамматика описывает, как строить правильные предложения, используя набор правил. Например, правило означает, что мы можем образовать глагольную фразу (VP), используя глагол (V), а затем именную фразу (NP).

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

Давайте прямо рассмотрим пример дерева синтаксического анализа округа для простого предложения «Я видел лису»:

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

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

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

Точно так же глагольная фраза делится на глагол и другую именную фразу. Как мы можем представить, это также соответствует другому правилу грамматики.

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

2.2. Анализ зависимостей

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

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

  1. Должен быть единственный корневой узел без входящих ребер.
  2. Для каждого узла должен быть путь от корня до.
  3. Каждый узел, кроме корня, должен иметь ровно 1 входящее ребро.

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

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

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

Например, слово «пила» имеет исходящую кромку типа nsubj по отношению к слову «я», что означает, что «я» является номинальным подлежащим глагола «пила». В этом случае мы говорим, что «I» зависит от «пилы» .

3. Проблемы анализа естественного языка

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

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

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

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

4. Примеры использования

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

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

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

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

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

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

5. Заключение

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

Авторы Внизу

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

Все еще анализирует строки пользовательского агента для ваших моделей машинного обучения? | Сергей Мастицкий

Используйте это вместо

Фотография Эмиля Перрона на Unsplash

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

Когда пользователь взаимодействует с веб-сайтом, браузер отправляет HTTP-запросы на сервер для получения необходимого контента, отправки данных или выполнения других действий.Такие запросы обычно содержат несколько заголовков, то есть символьных пар ключ-значение, которые определяют параметры данного запроса. Строка User-Agent (далее именуемая «UAS») представляет собой заголовок HTTP-запроса, который описывает программное обеспечение, действующее от имени пользователя (рисунок 1).

Рисунок 1. Браузер действует как агент пользователя при отправке запросов на сервер. Строка User-Agent описывает свойства браузера.

Первоначальной целью UAS было согласование контента , то есть механизм определения наилучшего контента для обслуживания пользователя в зависимости от информации, содержащейся в соответствующем UAS (например,g., формат изображения, язык документа, кодировка текста и т. д.). Эта информация обычно включает сведения о среде, в которой работает браузер (устройство, операционная система и ее версия, языковой стандарт), ядре и версии браузера, механизме макета и версии и т. Д. (Рисунок 2).

Рисунок 2. Пример типового БПЛА и его элементов.

Хотя в настоящее время обслуживание разных веб-страниц в разных браузерах считается плохой идеей, у UAS все еще есть много практических приложений. Самый распространенный — это веб-аналитика , т.е.е. отчетность о составе трафика для оптимизации эффективности веб-сайта. Другой вариант использования — это управление трафиком web , которое включает в себя блокировку мешающих поисковых роботов, снижение нагрузки на веб-сайт от нежелательных посетителей, предотвращение мошенничества с кликами и другие аналогичные задачи. Благодаря большому количеству информации, которую они содержат, UAS также может служить источником данных для приложений машинного обучения . Однако последний вариант использования пока не получил особого внимания. Здесь я обращаюсь к этой проблеме и обсуждаю эффективный способ создания информативных функций из UAS для моделей машинного обучения.Эта статья представляет собой краткое изложение моего выступления на двух конференциях — Почему R? и Корпоративные приложения языка R . Данные и код, используемые в примерах, описанных ниже, доступны на GitHub.

Элементы БПЛА часто могут служить полезными индикаторами характеристик пользователя, таких как образ жизни, техническая подкованность и даже достаток. Например, пользователь, который обычно посещает веб-сайт с мобильного устройства высокого класса, скорее всего, отличается от пользователя, посещающего тот же веб-сайт из Internet Explorer на настольном компьютере под управлением Windows XP.Наличие прокси на основе UAS для таких характеристик может быть особенно полезным, когда для пользователя недоступна другая демографическая информация (например, когда новый, неопознанный человек посещает веб-сайт).

В некоторых приложениях также может быть полезно различать человеческий и нечеловеческий веб-трафик. В некоторых случаях это просто сделать, поскольку автоматические поисковые роботы используют упрощенный формат UAS, который включает слово «бот» (например, Googlebot / 2.1 (+ http: //www.google.com/bot.html) ) .Однако некоторые сканеры не соблюдают это соглашение (например, боты Facebook содержат слово facebookexternalhit в своем UAS), и для их идентификации требуется словарь поиска.

Один, казалось бы, простой способ создать функции машинного обучения из UAS — это применить синтаксический анализатор , извлечь отдельные элементы UAS, а затем горячо кодировать эти элементы. Этот подход может хорошо работать в простых случаях, когда только высокоуровневые и легко идентифицируемые элементы UAS нуждаются в преобразовании в функции.Например, относительно легко определить тип оборудования пользовательского агента (мобильное, настольное или серверное и т. Д.). Для такого рода разработки функций можно использовать несколько высококачественных синтаксических анализаторов на основе регулярных выражений (например, см. Проект «ua-parser» и его реализации для выбора языков).

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

  • Существующие рекомендации по форматированию заголовков User-Agent никоим образом не применяются, и в реальном мире можно встретить большое количество спецификаций UAS. В результате последовательный разбор UAS, как известно, затруднен. Более того, каждый день появляются новые устройства и версии операционных систем и браузеров, что превращает обслуживание высококачественных парсеров в сложную задачу.
  • Число возможных элементов БПЛА и их комбинаций астрономически велико.Даже если бы их можно было сразу закодировать, результирующая матрица данных была бы чрезвычайно разреженной и слишком большой, чтобы поместиться в памяти компьютеров, обычно используемых специалистами по анализу данных в наши дни.

Чтобы преодолеть эти проблемы, можно применить метод уменьшения размерности и представить UAS как векторы фиксированного размера, минимизируя при этом потерю исходной информации. Эта идея, конечно, не нова, и поскольку UAS — это просто строки текста, это может быть достигнуто с помощью различных методов обработки естественного языка.В своих проектах я часто обнаруживал, что алгоритм fastText, разработанный исследователями из Facebook (Бояновски и др., 2016), дает особенно полезные решения.

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

  • он не требует данных, т.е. прилично работающую модель можно обучить только на нескольких тысячах примеров;
  • хорошо работает с краткими и структурированными документами, такими как UAS;
  • , как следует из названия, он быстро обучается;
  • хорошо справляется со «словами вне словарного запаса», т.е.е. он может генерировать значимые векторные представления (вложения) даже для строк, которые не были просмотрены во время обучения.

Официальная реализация fastText доступна как отдельная библиотека C ++ и как оболочка Python. Обе эти библиотеки хорошо документированы и просты в установке и использовании. Широко используемая библиотека Python gensim имеет собственную реализацию алгоритма. Ниже я продемонстрирую, как можно обучать модели fastText в R.

Существует несколько оболочек R вокруг библиотеки fastText C ++ (см. fastText , fastrtext и fastTextR ).Однако, пожалуй, самый простой способ обучить и использовать модели fastText в R — это вызвать официальные привязки Python через пакет reticulate . Импорт модуля Python fasttext в среду R можно выполнить следующим образом:

 # Сначала установите `fasttext` 
 # (см. Https://fasttext.cc/docs/en/support.html)# Загрузите` reticulate `package 
 # (при необходимости сначала установите): 
 require (reticulate) # Убедитесь, что` fasttext` доступен для R: 
 py_module_available ("fasttext") 
 ## [1] TRUE # Импортируйте `fasttext`: 
 ft <- import ("fasttext") # Затем вызовите необходимые методы, используя 
 # стандартную нотацию `$`, 
 # e.g .: `ft $ train_supervised ()`

Примеры, описанные ниже, основаны на выборке из 200 000 уникальных UAS из базы данных whatismybrowser.com (рисунок 3).

Рисунок 3. Образец БПЛА, использованный в примерах в этой статье. Данные хранятся в текстовом файле, где каждая строка содержит один UAS. Обратите внимание, что все UAS были нормализованы к нижнему регистру, и никакая другая предварительная обработка не применялась.

Обучение неконтролируемой модели fastText в R так же просто, как вызов команды, подобной следующей:

 m_unsup <- ft $ train_unsupervised (
 input = "./data/train_data_unsup.txt ", 
 model =" skipgram ", 
 lr = 0,05, 
 dim = 32L,  # размер вектора  
 ws = 3L, 
 minCount = 1L, 
 minn = 2L, 
 maxn = 6L, 
 neg = 3L, 
 wordNgrams = 2L, 
 loss = "ns", 
 epoch = 100L, 
 thread = 10L 
)

Аргумент dim в приведенной выше команде задает размерность встраиваемого пространства. В этом примере , мы хотим преобразовать каждый БПЛА в вектор размером 32. Остальные аргументы управляют процессом обучения модели ( lr — скорость обучения, потеря, — функция потерь, эпоха, — количество эпох и т. д.). Чтобы понять смысл всех аргументов, обратитесь к официальной документации fastText.

После обучения модели легко вычислить вложения для новых случаев (например, из набора тестов). В следующем примере показано, как это сделать (здесь ключевая команда m_unsup $ get_sentence_vector () , которая возвращает вектор, усредненный по вложениям отдельных элементов, составляющих данный UAS):

 test_data <- readLines ("./ data / test_data_unsup.txt ") 
 emb_unsup <- test_data%>% 
 lapply (., function (x) {
 m_unsup $ get_sentence_vector (text = x)%>% 
 t (.)%>% as.data.frame (.) 
})%>% 
 bind_rows (.)%>% 
 setNames (., paste0 ("f", 1:32)) 
 
 # Распечатка первых 5 значений 
 # векторов (размером 32) 
 #, которые представляют первые 3 UAS 
 # из тестового набора: emb_unsup [ 1: 3, 1: 5] 
 ## f1 f2 f3 f4 f5 
 ## 1 0,197 -0,03726 0,147 0,153 0,0423 
 ## 2 0,182 0,00307 0,147 0,101 0,0326 
 ## 3 0.101 -0,28220 0,189 0,202 -0,1623

Но как мы узнаем, хороша ли обученная модель без учителя? Конечно, один из способов проверить это будет включать включение векторных представлений UAS, полученных с помощью этой модели, в последующую задачу машинного обучения и оценку качества полученного решения. Однако, прежде чем переходить к последующей задаче моделирования, можно также визуально оценить, насколько хороши вложения fastText. Хорошо известные графики tSNE (Maaten & Hinton 2008; см. Также это видео на YouTube) могут быть особенно полезными.

Рис. 4. 3D tSNE-визуализация вложений, полученных с помощью неконтролируемой модели fastText. Каждая точка на этом графике соответствует UAS из набора тестов. Точки были обозначены цветом в соответствии с типом оборудования User Agent.

На рис. 4 показан трехмерный график вложений tSNE, рассчитанный для БПЛА из набора тестов с использованием указанной выше модели fastText. Хотя эта модель была обучена неконтролируемым образом, она смогла создать вложения, отражающие важные свойства исходных строк User-Agent.Например, хорошее разделение точек по типу оборудования.

Обучение контролируемой модели fastText по определению требует помеченных данных. Именно здесь существующие парсеры UAS часто могут оказаться большим подспорьем, поскольку их можно использовать для быстрой маркировки тысяч обучающих примеров. Алгоритм fastText поддерживает как мультиклассовые, так и многоклассовые классификаторы. Ожидаемый (по умолчанию) формат для меток — __label__ . Отформатированные таким образом ярлыки (и потенциально разделенные пробелом в случае модели с несколькими ярлыками) должны добавляться к каждому документу в наборе обучающих данных.

Предположим, нас интересуют вложения, которые подчеркивают различия в UAS в зависимости от типа оборудования. На рисунке 5 показан пример помеченных данных, которые подходят для обучения соответствующей модели.

Рисунок 5. Пример помеченных данных, подходящих для обучения контролируемой модели fastText.

Команда R, необходимая для обучения контролируемой модели fastText на таких помеченных данных, похожа на то, что мы видели раньше:

 m_sup <- ft $ train_supervised (
 input = "./data/train_data_sup.txt ", 
 lr = 0,05, 
 dim = 32L,  # размер вектора  
 ws = 3L, 
 minCount = 1L, 
 minCountLabel = 10L,  # минимальное количество меток  
 minn = 2L, 
 maxn = 6L, 
 neg = 3L, 
 wordNgrams = 2L, 
 loss = "softmax",  # функция потерь  
 epoch = 100L, 
 thread = 10L 
)

Мы можем оценить полученную контролируемую модель, вычислив точность, отзыв и оценка f1 на маркированном наборе тестов.Эти показатели могут быть рассчитаны для всех ярлыков или для отдельных ярлыков. Например, вот показатели качества для UAS, соответствующие метке «мобильный»:

 метрики <- m_sup $ test_label («./ data / test_data_sup.txt») 
 метрики [«__ label__mobile»] ## $ `__label__mobile` 
 ## $ `__label__mobile` $ precision 
 ## [1] 0,998351 
 ## 
 ## $` __label__mobile` $ отзыв 
 ## [1] 0,9981159 
 ## 
 ## $ `__label__mobile` $ f1score 
 ## [1] 0.9982334

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

Рис. 6. 3D tSNE-визуализация вложений, полученных с помощью модели fastText, обученной в контролируемом режиме, с метками, соответствующими типу оборудования.

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

Как написать собственный синтаксический анализатор JSON с использованием функционального TypeScript & fp ‑ ts — часть I

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

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

Мы будем использовать TypeScript и библиотеку fp-ts, и ожидается базовое знание функциональных концепций (композиция функций, неизменяемость) и типов данных (Option, Either).Тем не менее, код должен быть понятным, даже если вы не знакомы с такими, казалось бы, пугающими вещами, как функторы, моноиды или монады.

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

Формирование синтаксического анализатора

Сначала мы придадим нашему синтаксическому анализатору некоторую форму, определив некоторые типы. Каждому парсеру нужен ввод, и наш не исключение.

— КОД language-js —

‍
Определение типа синтаксического анализатора

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

Функция advance считывает один символ из ввода и возвращает его с остальной частью ввода . Возвращаемое значение обернуто внутри Option, чтобы представить состояние, когда больше нет символов для чтения (в этом случае возвращается none ).

Обратите внимание, что input является неизменным — мы создаем новый экземпляр каждый раз, когда продвигаем позицию.

Создание первого синтаксического анализатора

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

Мы прочитаем один символ из input с помощью расширенной функции и проверим, соответствует ли он ожидаемому символу.

Пора посмотреть, правильно ли ведет себя наш парсер.

Проверка функциональности

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

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

Изменение типов значений

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

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

Объединение нескольких синтаксических анализаторов в последовательность

Анализ простого символа был забавным, но как насчет объединения нескольких синтаксических анализаторов в один, который мог бы анализировать все слово?

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

Мы можем обобщить эту концепцию дальше, чтобы создать последовательность функций, которая может комбинировать любое количество экземпляров Parser . Обратите внимание, что мы выворачиваем тип наизнанку — мы предоставляем функции ReadonlyArray >> и получаем Parser >> < встроенный код> в результате.

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

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

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

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

Давайте реализуем это и назовем oneOf!

Объединение синтаксических анализаторов с несколькими параметрами

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

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

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

Следите за обновлениями … и работоспособно!

Комбинаторы монадического синтаксического анализатора на C #

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

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

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

Что такое парсер

Я уверен, что для большинства людей слово «синтаксический анализатор» не ново.В конце концов, мы все время «разбираем» вещи либо напрямую, например, с помощью таких, как int.Parse и XElement.Parse , либо косвенно при десериализации HTTP-ответов, чтении настроек приложения и т. Д.

А что такое парсер в общем смысле этого слова?

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

Например, видите ли вы какую-то логическую структуру, когда смотрите на 123 456,97 ? Вы легко можете сказать, что это номер, состоящий из нескольких компонентов:

По очевидным причинам компьютер не может обнаруживать подобные закономерности.В конце концов, он видит только кажущуюся случайной последовательность байтов: 31 32 33 20 34 35 36 2E 39 37 .

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

  новых SyntacticComponents []
{
    новый NumericLiteralComponent (123),
    новый компонент ThousandsSeparatorComponent (""),
    новый NumericLiteralComponent (456),
    новый DecimalSeparatorComponent ("."),
    новый NumericLiteralComponent (97)
}

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

  ------ (Парсер)
               / \
            ✓ / \ X
             / \

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

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

Формальная грамматика

Анализ чисел

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

Говоря о регулярных выражениях, знаете ли вы, почему они называются регулярными ?

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

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

В зависимости от сложности этих правил грамматики делятся на разные типы в соответствии с иерархией Хомского. На самом низком уровне вы найдете два наиболее распространенных типа грамматики: обычные и контекстно-свободные грамматики.

  + --------------------------------- +
| |
| БЕСКОНТЕКСТОВЫЕ ГРАММАТИКИ |
| |
| |
| + -------------------- + |
| | | |
| | ОБЫЧНЫЕ ГРАММАТИКИ | |
| | | |
| + -------------------- + |
+ --------------------------------- +

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

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

В результате, в то время как ввод, который придерживается обычной грамматики, может быть представлен с использованием последовательности синтаксических компонентов, контекстно-свободная грамматика представлена ​​с использованием структуры более высокого уровня — синтаксического дерева:

  [документ HTML]
          | \
          | \
         
        / \ \
     <основной> <нижний колонтитул> \
      / | \
   
 
  </code> </pre><p> Итак, если мы не можем использовать регулярные выражения для построения этих синтаксических деревьев, что нам делать?</p><h3><span class="ez-toc-section" id="%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D1%8B_%D1%81%D0%B8%D0%BD%D1%82%D0%B0%D0%BA%D1%81%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B3%D0%BE_%D0%B0%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%82%D0%BE%D1%80%D0%B0"></span> Комбинаторы синтаксического анализатора <span class="ez-toc-section-end"></span></h3><p> Есть много подходов к написанию синтаксических анализаторов для контекстно-свободных языков.Большинство известных вам языковых инструментов построено либо с использованием ручных синтаксических анализаторов стека циклов, либо с помощью фреймворков генератора синтаксических анализаторов, либо с помощью комбинаторов синтаксических анализаторов.</p><p> Комбинаторы синтаксического анализатора, как концепция, вращаются вокруг представления каждого синтаксического анализатора как модульной функции, которая принимает некоторые входные данные и выдает либо успешный результат, либо ошибку:</p><pre> <code> f (ввод) -> (результат, inputRemainder) | (ошибка) </code> </pre><p> Эти синтаксические анализаторы можно преобразовать или объединить для формирования более сложных синтаксических анализаторов, заключив функцию в другую функцию.Вообще говоря, комбинаторы — это просто еще один класс функций, которые берут на себя другие функции синтаксического анализатора и создают более сложные.</p><p> Идея состоит в том, чтобы начать с написания синтаксических анализаторов простейших грамматических правил вашего языка, а затем постепенно продвигаться вверх по иерархии, используя различные комбинаторы. Поднимаясь уровень за уровнем, вы в конечном итоге должны достичь самого верхнего узла, который представляет так называемый начальный символ.</p><p> Это может быть слишком абстрактным для понимания, так как насчет практического примера?</p><h3><span class="ez-toc-section" id="%D0%9F%D1%80%D0%BE%D1%86%D0%B5%D1%81%D1%81%D0%BE%D1%80_JSON_%D1%81_%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5%D0%BC_%D0%BA%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BE%D0%B2_%D1%81%D0%B8%D0%BD%D1%82%D0%B0%D0%BA%D1%81%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B3%D0%BE_%D0%B0%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%82%D0%BE%D1%80%D0%B0"></span> Процессор JSON с использованием комбинаторов синтаксического анализатора <span class="ez-toc-section-end"></span></h3><p> Чтобы лучше понять этот подход, давайте напишем функциональный парсер JSON с использованием C # и библиотеки Sprache.Эта библиотека предоставляет набор базовых низкоуровневых синтаксических анализаторов и методов для их объединения, которые по сути являются строительными блоками, которые мы можем использовать для создания наших собственных сложных синтаксических анализаторов.</p><p> Для начала я создал проект и определил классы, которые представляют различные сущности в грамматике JSON, всего 6 из них:</p><ul><li> <code> JsonObject </code></li><li> <code> JsonArray </code></li><li> <code> JsonString </code></li><li> <code> JsonNumber </code></li><li> <code> JsonBoolean </code></li><li> <code> JsonNull </code></li></ul><p> Вот соответствующий код для них, для краткости сжатый в один фрагмент:</p><pre> <code>
общедоступный абстрактный класс JsonEntity
{
    общедоступный виртуальный JsonEntity this [имя строки] =>
        выбросить новое исключение InvalidOperationException ($ "{GetType ().Name} не поддерживает эту операцию. ");

    общедоступный виртуальный JsonEntity this [int index] =>
        throw new InvalidOperationException ($ "{GetType (). Name} не поддерживает эту операцию.");

    общедоступный виртуальный T GetValue <T> () =>
        throw new InvalidOperationException ($ "{GetType (). Name} не поддерживает эту операцию.");

    общедоступный статический анализ JsonEntity (строка json) =>
        throw new NotImplementedException («Еще не реализовано!»);
}


открытый класс JsonObject: JsonEntity
{
    общедоступный IReadOnlyDictionary <строка, JsonEntity> Свойства {получить; }

    общедоступный JsonObject (свойства IReadOnlyDictionary <string, JsonEntity>)
    {
        Свойства = свойства;
    }

    общедоступное переопределение JsonEntity this [имя строки] =>
        Характеристики.TryGetValue (имя, результат var)? результат: null;
}


открытый класс JsonArray: JsonEntity
{
    public IReadOnlyList <JsonEntity> Дети {получить; }

    общедоступный JsonArray (дети IReadOnlyList <JsonEntity>)
    {
        Дети = дети;
    }

    публичное переопределение JsonEntity this [int index] => Children.ElementAtOrDefault (index);
}


общедоступный абстрактный класс JsonLiteral <TValue>: JsonEntity
{
    общественное значение TValue {получить; }

    защищенный JsonLiteral (значение TValue)
    {
        Значение = значение;
    }

    публичное переопределение T GetValue <T> () => (T) Convert.ChangeType (Значение, typeof (T));
}


открытый класс JsonString: JsonLiteral <string>
{
    public JsonString (строковое значение): base (значение)
    {
    }
}



открытый класс JsonNumber: JsonLiteral <double>
{
    public JsonNumber (двойное значение): base (значение)
    {
    }
}



открытый класс JsonBoolean: JsonLiteral <bool>
{
    общедоступный JsonBoolean (значение типа bool): base (значение)
    {
    }
}


открытый класс JsonNull: JsonLiteral <объект>
{
    общедоступный JsonNull (): base (null)
    {
    }
} </code> </pre><p> Вы можете видеть, что все наши типы JSON наследуются от класса <code> JsonEntity </code>, который определяет несколько виртуальных методов.Эти методы вызывают исключение по умолчанию, но они переопределяются правильной реализацией для типов, которые их поддерживают.</p><p> Используя <code> JsonEntity.Parse </code>, вы можете преобразовать фрагмент текста JSON в объекты нашего домена и пройти всю иерархию с помощью индексаторов:</p><pre> <code> var price = JsonEntity.Parse (json) ["заказ"] ["элементы"] [0] ["цена"]. GetValue <double> (); </code> </pre><p> Конечно, это пока не сработает, потому что наш метод <code> Parse </code> не реализован.Давай исправим это.</p><p> Начните с загрузки библиотеки Sprache из NuGet, затем создайте новый внутренний статический класс с именем <code> JsonGrammar </code>. Здесь мы определим грамматику для нашего языка:</p><pre> <code> внутренний статический класс JsonGrammar
{
} </code> </pre><p> Как я объяснил выше, этот подход заключается в построении сначала простых независимых синтаксических анализаторов и постепенном продвижении вверх по иерархии. По этой причине имеет смысл начать с самой простой сущности, <code> JsonNull </code>, которая может иметь только одно значение:</p><pre> <code> внутренний статический класс JsonGrammar
{
    частный статический только для чтения Parser <JsonNull> JsonNull =
        Разобрать.Строка ("ноль"). Возврат (новый JsonNull ());
} </code> </pre><p> Давайте быстро разберемся с тем, что мы здесь только что написали.</p><p> Справа от знака равенства мы вызываем <code> Parse.String </code>, чтобы создать базовый синтаксический анализатор, который будет искать последовательность символов, составляющих строку «null». Этот метод создает делегат типа <code> Parser <IEnumerable <char>> </code>, но, поскольку нас не особо интересует сама последовательность символов, мы связываем ее с методом расширения <code> Return </code>, который позволяет нам указать конкретный объект для возврата вместо.Это также изменяет тип делегата на <code> Parser <JsonNull> </code>.</p><p> Стоит отметить, что пока мы пишем это, синтаксический анализ еще не происходит. Мы только создаем делегат, который позже может быть вызван для анализа определенного ввода.</p><p> Если мы вызовем <code> JsonNull.Parse ("null") </code>, он вернет объект типа <code> JsonNull </code>. Если мы попытаемся вызвать его на любом другом входе, он выдаст исключение с подробной ошибкой.</p><p> Это круто, но пока не особо полезно.</p><p> Перейдем к <code> JsonBoolean </code>. Этот тип, в отличие от <code>, JsonNull </code> фактически имеет два потенциальных состояния: <code> истинный </code> и <code> ложный </code>. Мы можем обрабатывать их с помощью двух отдельных парсеров:</p><pre> <code> внутренний статический класс JsonGrammar
{
    

    частный статический только для чтения Parser <JsonBoolean> TrueJsonBoolean =
        Parse.String ("true"). Return (new JsonBoolean (true));

    частный статический только для чтения Parser <JsonBoolean> FalseJsonBoolean =
        Разобрать.String ("false"). Return (new JsonBoolean (false));
} </code> </pre><p> Это работает очень похоже на предыдущий синтаксический анализатор, который мы написали, за исключением того, что теперь у нас есть два разных синтаксических анализатора для одной сущности.</p><p> Как вы, наверное, догадались, именно здесь в игру вступают комбинаторы. Мы можем объединить эти два парсера в один, используя комбинатор <code> или </code> следующим образом:</p><pre> <code> внутренний статический класс JsonGrammar
{
    

    частный статический только для чтения Parser <JsonBoolean> TrueJsonBoolean =
        Разобрать.Строка ("истина"). Возврат (новый JsonBoolean (истина));

    частный статический только для чтения Parser <JsonBoolean> FalseJsonBoolean =
        Parse.String ("false"). Return (new JsonBoolean (false));

    частный статический только для чтения Parser <JsonBoolean> JsonBoolean =
        TrueJsonBoolean.Or (FalseJsonBoolean);
} </code> </pre><p> Комбинатор <code> или </code> — это метод расширения, который принимает два синтаксических анализатора одного типа и создает новый синтаксический анализатор, который завершается успешно, если один из них завершается успешно. Это означает, что если мы попытаемся вызвать <code> JsonBoolean.Parse ("true") </code>, мы получим <code> JsonBoolean </code>, который имеет значение <code> Value </code>, равное <code> true </code>. Точно так же, если мы вызовем <code> JsonBoolean.Parse ("false") </code>, мы получим <code> JsonBoolean </code>, значение <code> которого </code> равно <code> false </code>. И, конечно же, любой неожиданный ввод приведет к ошибке.</p><p> Одна из самых крутых особенностей использования комбинаторов синтаксического анализатора — это то, насколько выразителен ваш код. На самом деле, это можно прочитать буквально:</p><pre> <code> JsonBoolean имеет значение TrueJsonBoolean или FalseJsonBoolean.TrueJsonBoolean - это строка «true», которая производит JsonBoolean, значение которого равно «true».
FalseJsonBoolean - это строка «false», которая создает JsonBoolean, значение которого равно «false». </code> </pre><p> Чтение подобного кода позволяет легко определить структуру текста, который мы пытаемся разобрать.</p><p> Давайте обработаем наш следующий тип данных, <code> JsonNumber </code>:</p><pre> <code> внутренний статический класс JsonGrammar
{
    

    частный статический анализатор только для чтения <JsonNumber> JsonNumber =
        Разобрать.ДесятичныйИнвариант
            .Select (s => double.Parse (s, CultureInfo.InvariantCulture))
            .Select (v => новый номер JsonNumber (v));
} </code> </pre><p> Как видите, Sprache уже «из коробки» предоставляет <code> Parse.DecimalInvariant </code>, который мы можем использовать для сопоставления числа. Поскольку это возвращает <code> Parser <string> </code>, когда он анализирует текст, представляющий число, нам нужно сначала преобразовать его в <code> double </code>, а затем в наш объект <code> JsonNumber </code>.</p><p> Метод <code> Select </code> здесь работает аналогично методу <code> Select </code> в LINQ — он лениво преобразует базовое значение контейнера в другую форму.Это позволяет отображать необработанные последовательности символов в более сложные объекты предметной области более высокого уровня.</p><p> Между прочим, типы, которые имеют операцию <code> Select </code> (или, в просторечии, операцию «сопоставление»), называются «функторами». Как видите, они не ограничиваются коллекциями (например, <code> IEnumerable<T> </code>), но также могут быть контейнерами с одним значением, как наш <code> Parser<T> </code> здесь.</p><p> Разобравшись с этим, перейдем к <code> JsonString </code>:</p><pre> <code> внутренний статический класс JsonGrammar
{
    

    частный статический анализатор только для чтения <JsonString> JsonString =
        из открытого в Parse.Char ('"')
        от значения в Parse.CharExcept ('"'). Many (). Text ()
        из закрытия в Parse.Char ('"')
        выберите новый JsonString (значение);
} </code> </pre><p> Здесь вы можете увидеть, как мы объединили три последовательных синтаксических анализатора в один с использованием синтаксиса понимания LINQ. Вы, наверное, знакомы с этим синтаксисом по работе с коллекциями, но здесь он немного другой.</p><p> Каждая строка, начинающаяся с <code> из </code>, представляет отдельный синтаксический анализатор, который производит значение. Мы указываем имя для значения слева и определяем фактический синтаксический анализатор справа.Чтобы свести параметры к одному результату, мы заканчиваем оператором <code> select </code>, который конструирует объект, который нам нужен.</p><p> Это работает, потому что связывание <code> с операторами </code> внутренне вызывает метод расширения <code> SelectMany </code>, который автор этой библиотеки определил для работы с <code> Parser<T> </code>.</p><p> Да, и типы, которые позволяют делать это с помощью <code> SelectMany </code> (также известного как «плоская карта»), мы называем «монадами».</p><p> Синтаксический анализатор, который мы только что написали, попытается сопоставить двойную кавычку, за которой следует (возможно, пустая) последовательность символов, не содержащая двойных кавычек, заканчивающаяся другой двойной кавычкой, в конечном итоге возвращая объект <code> JsonString </code> с текстом внутри .</p><p> Переходим к нашему первому непримитивному типу, <code> JsonArray </code>:</p><pre> <code> внутренний статический класс JsonGrammar
{
    

    частный статический только для чтения Parser <JsonArray> JsonArray =
        из открытого в Parse.Char ('[')
        от детей в JsonEntity.Token (). DelimitedBy (Parse.Char (','))
        из закрытия в Parse.Char (']')
        выберите новый JsonArray (children.ToArray ());
} </code> </pre><p> Структурно массив JSON представляет собой просто последовательность сущностей, разделенных запятыми, заключенных в пару квадратных скобок.Мы можем определить это, используя комбинатор <code> DelimitedBy </code>, который пытается сопоставить первый синтаксический анализатор, многократно разделенный вторым.</p><p> Обратите внимание, что этот комбинатор принимает <code> Parse.Char (',') </code> вместо <code> ',' </code>. На самом деле мы могли бы использовать вместо него более сложный синтаксический анализатор, который даже не возвращает <code> char </code> или <code> строку </code>. В этом сила комбинаторов синтаксического анализатора — по мере того, как мы постепенно продвигаемся вверх по структуре наших данных, мы работаем с синтаксическими анализаторами все более высокого порядка.</p><p> Если вы внимательно следовали приведенным здесь инструкциям, то, вероятно, заметили, что приведенный выше код на самом деле не компилируется. Это потому, что мы ссылаемся на <code> JsonEntity </code>, который является синтаксическим анализатором, который мы еще не определили. Это потому, что это правило грамматики является рекурсивным — массив может содержать любую сущность, которая может быть, помимо прочего, массивом, который может содержать любую сущность, которая может быть массивом, что… вы понимаете.</p><p> В качестве временного решения мы можем определить фиктивный объект вместо <code> JsonEntity </code>, просто чтобы он скомпилировался:</p><pre> <code> внутренний статический класс JsonGrammar
{
    

    частный статический только для чтения Parser <JsonArray> JsonArray =
        из открытого в Parse.Char ('[')
        от детей в JsonEntity.Token (). DelimitedBy (Parse.Char (','))
        из закрытия в Parse.Char (']')
        выберите новый JsonArray (children.ToArray ());

    общедоступный статический только для чтения Parser <JsonEntity> JsonEntity = null;
} </code> </pre><p> Также обратите внимание на метод расширения <code> Token () </code>? Это превращает наш синтаксический анализатор в синтаксический анализатор более высокого порядка, который сразу же использует все пробелы вокруг нашего ввода. Как мы знаем, JSON игнорирует пробелы, если они не заключены в двойные кавычки, поэтому нам необходимо это учитывать.Если мы этого не сделаем, наш синтаксический анализатор выдаст ошибку при обнаружении пробелов.</p><p> Анализ <code> JsonObject </code> очень похож, за исключением того, что он содержит свойства вместо необработанных сущностей. Итак, сначала нам нужно начать с парсера:</p><pre> <code> внутренний статический класс JsonGrammar
{
    

    частный статический только для чтения Parser <KeyValuePair <string, JsonEntity >> JsonProperty =
        от имени в JsonString.Select (s => s.Value)
        из двоеточия в Parse.Char (':').Токен ()
        от значения в JsonEntity
        выберите новый KeyValuePair <строка, JsonEntity> (имя, значение);

    частный статический только для чтения Parser <JsonObject> JsonObject =
        из открытого в Parse.Char ('{')
        из свойств в JsonProperty.Token (). DelimitedBy (Parse.Char (','))
        из закрытия в Parse.Char ('}')
        выберите новый JsonObject (properties.ToDictionary (p => p.Key, p => p.Value));

    
} </code> </pre><p> Поскольку наша модель реализует <code> JsonObject </code> с использованием словаря, отдельное свойство выражается с помощью <code> KeyValuePair <string, JsonEntity> </code>, то есть имени свойства (<code> string </code>) и его значения (<code> JsonEntity </code>).</p><p> Как видите, мы снова использовали синтаксис понимания LINQ для объединения последовательных синтаксических анализаторов. <code> JsonProperty </code> состоит из <code> JsonString </code> для имени, двоеточия и <code> JsonEntity </code>, обозначающего его значение. Мы используем <code> Select () </code> на <code> JsonString </code> для ленивого извлечения только необработанного значения <code> string </code>, поскольку нас не интересует сам объект.</p><p> Для парсера <code> JsonObject </code> мы практически написали тот же код, что и для <code> JsonArray </code>, заменив квадратные скобки фигурными скобками и <code> JsonEntity </code> на <code> JsonProperty </code>.</p><p> Наконец, завершив работу с каждым отдельным типом сущности, мы можем правильно определить <code> JsonEntity </code>, объединив синтаксические анализаторы, которые мы написали ранее:</p><pre> <code> внутренний статический класс JsonGrammar
{
    

    общедоступный статический анализатор только для чтения <JsonEntity> JsonEntity =
        JsonObject
            .Или <JsonEntity> (JsonArray)
            .Or (JsonString)
            .Or (JsonNumber)
            .Или (JsonBoolean)
            .Or (JsonNull);
} </code> </pre><p> И обновите статический метод, который у нас есть в самом классе <code> JsonEntity </code>, чтобы он вызывал соответствующий парсер:</p><pre> <code> открытый абстрактный класс JsonEntity
{
    

    общедоступный статический анализ JsonEntity (строка json) => JsonGrammar.JsonEntity.Parse (json);
} </code> </pre><p> Вот и все, JSON-процессор у нас рабочий! Теперь мы можем вызвать <code> JsonEntity.Parse </code> для любого допустимого текста JSON и преобразовать его в наш домен, то есть в дерево из <code> объектов JsonEntity </code>.</p><h3><span class="ez-toc-section" id="%D0%9F%D0%BE%D0%B4%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5_%D0%B8%D1%82%D0%BE%D0%B3%D0%BE%D0%B2"></span> Подведение итогов <span class="ez-toc-section-end"></span></h3> Разбор<p> не должен быть сложной и недоступной задачей. Функциональное программирование помогает нам моделировать сложную грамматику как композицию более мелких функций, о которых довольно легко рассуждать. И, к счастью, мы можем сделать это и на C #!</p><p> Если вы все еще жаждете знаний и хотите увидеть немного более сложный пример, обратите внимание на LtGt, процессор HTML (с селекторами CSS!), Который я изначально написал с использованием Sprache.</p><p> Если вы хотите узнать больше о синтаксическом анализе в целом, я рекомендую прочитать статью Габриэле Томассетти «Анализ в C #».</p><p> Есть также другие библиотеки комбинаторов монадического синтаксического анализатора в .NET, которые вы можете проверить, в первую очередь Superpower, Pidgin, Parsley и FParsec (F #).</p><p> Эта статья в значительной степени основана на моем выступлении с .NET Fest 2019 «Комбинаторы монадического синтаксического анализатора в C #». Здесь вы можете найти исходную презентацию и полный исходный код парсера JSON.</p><h2><span class="ez-toc-section" id="%D0%A0%D1%83%D0%BA%D0%BE%D0%B2%D0%BE%D0%B4%D1%81%D1%82%D0%B2%D0%BE_%D0%BF%D0%BE_%D1%81%D1%82%D0%B8%D0%BB%D1%8E_%7C_Vue_js"></span> Руководство по стилю | Vue.js <span class="ez-toc-section-end"></span></h2><p data-v-d5cc771c=""> Это официальное руководство по стилю для кода, специфичного для Vue. Если вы используете Vue в проекте, это отличный справочник, позволяющий избежать ошибок, сбоев и анти-шаблонов. Однако мы не считаем, что какое-либо руководство по стилю идеально подходит для всех команд или проектов, поэтому поощряются осознанные отклонения, основанные на прошлом опыте, окружающем технологическом стеке и личных ценностях.</p><p data-v-d5cc771c=""> По большей части мы также избегаем предложений относительно JavaScript или HTML в целом. Мы не против того, используете ли вы точку с запятой или конечную запятую.Нас не волнует, использует ли ваш HTML одинарные или двойные кавычки для значений атрибутов. Однако будут существовать некоторые исключения, когда мы обнаружили, что определенный шаблон полезен в контексте Vue.</p><p data-v-d5cc771c=""> Наконец, мы разделили правила на четыре категории:</p><h3 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9A%D0%B0%D1%82%D0%B5%D0%B3%D0%BE%D1%80%D0%B8%D0%B8_%D0%BF%D1%80%D0%B0%D0%B2%D0%B8%D0%BB"></span> Категории правил <span class="ez-toc-section-end"></span></h3><h4 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D1%80%D0%B8%D0%BE%D1%80%D0%B8%D1%82%D0%B5%D1%82_A_%D0%A1%D1%83%D1%89%D0%B5%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9"></span> Приоритет A: Существенный <span class="ez-toc-section-end"></span></h4><p data-v-d5cc771c=""> Эти правила помогают предотвратить ошибки, поэтому изучите их и соблюдайте их любой ценой. Могут существовать исключения, но они должны быть очень редкими и делаться только теми, кто обладает экспертными знаниями как JavaScript, так и Vue.</p><h4 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D1%80%D0%B8%D0%BE%D1%80%D0%B8%D1%82%D0%B5%D1%82_B_%D0%BD%D0%B0%D1%81%D1%82%D0%BE%D1%8F%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D0%BE_%D1%80%D0%B5%D0%BA%D0%BE%D0%BC%D0%B5%D0%BD%D0%B4%D1%83%D0%B5%D1%82%D1%81%D1%8F"></span> Приоритет B: настоятельно рекомендуется <span class="ez-toc-section-end"></span></h4><p data-v-d5cc771c=""> Было обнаружено, что эти правила улучшают читаемость и / или удобство разработки в большинстве проектов. Ваш код все равно будет работать, если вы их нарушите, но нарушения должны быть редкими и хорошо обоснованными.</p><h4 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D1%80%D0%B8%D0%BE%D1%80%D0%B8%D1%82%D0%B5%D1%82_C_%D1%80%D0%B5%D0%BA%D0%BE%D0%BC%D0%B5%D0%BD%D0%B4%D1%83%D0%B5%D1%82%D1%81%D1%8F"></span> Приоритет C: рекомендуется <span class="ez-toc-section-end"></span></h4><p data-v-d5cc771c=""> Если существует несколько одинаково хороших вариантов, можно сделать произвольный выбор для обеспечения согласованности. В этих правилах мы описываем каждый приемлемый вариант и предлагаем вариант по умолчанию. Это означает, что вы можете свободно делать другой выбор в своей собственной кодовой базе, если вы последовательны и имеете вескую причину.Пожалуйста, имейте вескую причину! Приспосабливаясь к стандарту сообщества, вы:</p><ol data-v-d5cc771c=""><li data-v-d5cc771c=""> научите свой мозг более легкому синтаксическому анализу большей части кода сообщества, с которым вы сталкиваетесь</li><li data-v-d5cc771c=""> сможете копировать и вставлять большинство примеров кода сообщества без изменений</li><li data-v-d5cc771c=""> часто обнаруживаете, что новые сотрудники уже привыкли в соответствии с вашим предпочтительным стилем кодирования, по крайней мере, в отношении Vue</li></ol><h4 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D1%80%D0%B8%D0%BE%D1%80%D0%B8%D1%82%D0%B5%D1%82_D_%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D1%83%D0%B9%D1%82%D0%B5_%D1%81_%D0%BE%D1%81%D1%82%D0%BE%D1%80%D0%BE%D0%B6%D0%BD%D0%BE%D1%81%D1%82%D1%8C%D1%8E"></span> Приоритет D: используйте с осторожностью <span class="ez-toc-section-end"></span></h4><p data-v-d5cc771c=""> Некоторые функции Vue существуют для учета редких крайних случаев или более плавной миграции из устаревшей кодовой базы.Однако при чрезмерном использовании они могут затруднить поддержку вашего кода или даже стать источником ошибок. Эти правила проливают свет на потенциально опасные особенности, описывая, когда и почему их следует избегать.</p><h3 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D1%80%D0%B0%D0%B2%D0%B8%D0%BB%D0%B0_%D0%BF%D1%80%D0%B8%D0%BE%D1%80%D0%B8%D1%82%D0%B5%D1%82%D0%B0_A_Essential"></span> Правила приоритета A: Essential <span class="ez-toc-section-end"></span></h3><h4 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%98%D0%BC%D0%B5%D0%BD%D0%B0_%D0%BA%D0%BE%D0%BC%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%82%D0%BE%D0%B2_%D0%B8%D0%B7_%D0%BD%D0%B5%D1%81%D0%BA%D0%BE%D0%BB%D1%8C%D0%BA%D0%B8%D1%85_%D1%81%D0%BB%D0%BE%D0%B2"></span> Имена компонентов из нескольких слов <span class="ez-toc-section-end"></span></h4><sup data-p="a" data-v-d5cc771c=""> essential </sup></h4><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Имена компонентов всегда должны состоять из нескольких слов, за исключением корневых компонентов <code data-v-d5cc771c=""> App </code> и встроенных компонентов, предоставляемых Vue, таких как <code data-v-d5cc771c=""> < переход> </code> или <code data-v-d5cc771c=""> <компонент> </code>.</strong></p><p data-v-d5cc771c=""> Это предотвращает конфликты (открывает новое окно) с существующими и будущими элементами HTML, поскольку все элементы HTML представляют собой одно слово.</p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D0%BB%D0%BE%D1%85%D0%BE"></span> Плохо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> app.component ('todo', {
  
})
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> экспорт по умолчанию {
  имя: 'Todo',
  
}
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/></p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%A5%D0%BE%D1%80%D0%BE%D1%88%D0%BE"></span> Хорошо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> app.component ('todo-item', {
  
})
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> экспорт по умолчанию {
  имя: 'TodoItem',
  
}
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/></p><h4 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9E%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F_%D0%BE%D0%BF%D0%BE%D1%80"></span> Определения опор <span class="ez-toc-section-end"></span></h4><sup data-p="a" data-v-d5cc771c=""> обязательные </sup></h4><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Определения опор должны быть как можно более подробными.</strong></p><p data-v-d5cc771c=""> В зафиксированном коде определения свойств всегда должны быть как можно более подробными, указывая как минимум тип (ы).</p> Подробное объяснение<p data-v-d5cc771c=""> Подробные определения свойств имеют два преимущества:</p><ul data-v-d5cc771c=""><li data-v-d5cc771c=""> Они документируют API компонента, так что легко увидеть, как компонент предназначен для использования.</li><li data-v-d5cc771c=""> В процессе разработки Vue предупредит вас, если компонент когда-либо предоставит неверно отформатированные свойства, что поможет вам выявить потенциальные источники ошибок.</li></ul><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%A5%D0%BE%D1%80%D0%BE%D1%88%D0%B8%D0%B5"></span> Хорошие <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> опоры: {
  статус: Строка
}
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c="">
props: {
  статус: {
    тип: String,
    требуется: true,

    валидатор: значение => {
      возвращение [
        'синхронизации',
        "синхронизировано",
        'конфликт версий',
        'ошибка'
      ].включает (значение)
    }
  }
}
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/> 8 <br data-v-d5cc771c=""/> 9 <br data-v-d5cc771c=""/> 10 <br data-v-d5cc771c=""/> 11 <br data-v-d5cc771c=""/> 12 <br data-v-d5cc771c=""/> 13 <br data-v-d5cc771c=""/> 14 <br data-v-d5cc771c=""/> 15 <br data-v-d5cc771c=""/> 16 <br data-v-d5cc771c=""/></p><h4 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9A%D0%BB%D1%8E%D1%87"></span> Ключ <span class="ez-toc-section-end"></span></h4><code data-v-d5cc771c=""> v-для </code></h4>20 Essential 905 используйте ключ <code data-v-d5cc771c=""> </code> с <code data-v-d5cc771c=""> v-для </code>. </strong></p><p data-v-d5cc771c=""> <code data-v-d5cc771c=""> ключ </code> с <code data-v-d5cc771c=""> v-для </code> — <em data-v-d5cc771c=""> всегда </em> требуется для компонентов, чтобы поддерживать внутреннее состояние компонента в поддереве.Однако даже для элементов рекомендуется поддерживать предсказуемое поведение, например постоянство объекта (открывает новое окно) в анимации.</p> Подробное объяснение<p data-v-d5cc771c=""> Допустим, у вас есть список задач:</p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> data () {
  возвращение {
    задачи: [
      {
        id: 1,
        текст: 'Научитесь использовать v-for'
      },
      {
        id: 2,
        текст: "Научитесь пользоваться ключом"
      }
    ]
  }
}
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/> 8 <br data-v-d5cc771c=""/> 9 <br data-v-d5cc771c=""/> 10 <br data-v-d5cc771c=""/> 11 <br data-v-d5cc771c=""/> 12 <br data-v-d5cc771c=""/> 13 <br data-v-d5cc771c=""/> 14 <br data-v-d5cc771c=""/></p><p data-v-d5cc771c=""> Затем вы сортируете их в алфавитном порядке.При обновлении DOM Vue оптимизирует рендеринг для выполнения самых дешевых мутаций DOM. Это может означать удаление первого элемента todo, а затем его повторное добавление в конец списка.</p><p data-v-d5cc771c=""> Проблема в том, что бывают случаи, когда важно не удалять элементы, которые останутся в DOM. Например, вы можете использовать <code data-v-d5cc771c=""> <transition-group> </code> для анимации сортировки списка или сохранить фокус, если визуализированный элемент — это <code data-v-d5cc771c=""> <input> </code>. В этих случаях добавление уникального ключа для каждого элемента (например,г. <code data-v-d5cc771c="">: key = "todo.id" </code>) укажет Vue, как вести себя более предсказуемо.</p><p data-v-d5cc771c=""> По нашему опыту, <em data-v-d5cc771c=""> всегда лучше </em> добавлять уникальный ключ, чтобы вам и вашей команде просто не приходилось беспокоиться об этих крайних случаях. Затем в редких, критичных к производительности сценариях, когда постоянство объекта не требуется, вы можете сделать сознательное исключение.</p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D0%BB%D0%BE%D1%85%D0%BE-2"></span> Плохо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> <ul>
  <li v-for = "todo in todos">
    {{todo.text}}
  </li>
</ul>
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/></p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%A5%D0%BE%D1%80%D0%BE%D1%88%D0%BE-2"></span> Хорошо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> <ul>
  <Ли
    v-for = "todo in todos"
    : key = "todo.я бы"
  >
    {{todo.text}}
  </li>
</ul>
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/> 8 <br data-v-d5cc771c=""/></p><h4 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%98%D0%B7%D0%B1%D0%B5%D0%B3%D0%B0%D0%B9%D1%82%D0%B5"></span> Избегайте <span class="ez-toc-section-end"></span></h4><code data-v-d5cc771c=""> v-if </code> с <code data-v-d5cc771c=""> v-для </code> <sup data-p="a" data-v-d5cc771c=""> Essential </sup></h4><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Никогда не используйте <code data-v-d5cc771c=""> v-same на </code> как <code data-v-d5cc771c=""> v-для </code>. </strong></p><p data-v-d5cc771c=""> Есть два распространенных случая, когда это может показаться заманчивым:</p><ul data-v-d5cc771c=""><li data-v-d5cc771c=""><p data-v-d5cc771c=""> Для фильтрации элементов в списке (например, <code data-v-d5cc771c=""> v-for = "user in users" v-if = "user.isActive "</code>). В этих случаях замените <code data-v-d5cc771c=""> users </code> новым вычисляемым свойством, которое возвращает ваш отфильтрованный список (например, <code data-v-d5cc771c=""> activeUsers </code>).</p></li><li data-v-d5cc771c=""><p data-v-d5cc771c=""> Чтобы избежать отображения списка, если он должен быть скрыт (например, <code data-v-d5cc771c=""> v-for = "user in users" v-if = "shouldShowUsers" </code>). В этих случаях переместите <code data-v-d5cc771c=""> v-if </code> в элемент контейнера (например, <code data-v-d5cc771c=""> ul </code>, <code data-v-d5cc771c=""> ol </code>).</p></li></ul> Подробное объяснение<p data-v-d5cc771c=""> Когда Vue директивы процессов, <code data-v-d5cc771c=""> v-if </code> имеет более высокий приоритет, чем <code data-v-d5cc771c=""> v-for </code>, так что этот шаблон:</p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> <ul>
  <Ли
    v-for = "пользователь среди пользователей"
    v-if = "пользователь.isActive "
    : key = "user.id"
  >
    {{ имя пользователя }}
  </li>
</ul>
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/> 8 <br data-v-d5cc771c=""/> 9 <br data-v-d5cc771c=""/></p><p data-v-d5cc771c=""> Выдает ошибку, потому что сначала будет вычислена директива <code data-v-d5cc771c=""> v-if </code>, а переменная итерации <code data-v-d5cc771c=""> user </code> не существует в этот момент.</p><p data-v-d5cc771c=""> Это можно исправить, перебирая вычисленное свойство, например:</p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> вычислено: {
  activeUsers () {
    верни это.users.filter (пользователь => user.isActive)
  }
}
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> <ul>
  <Ли
    v-for = "пользователь в активных пользователях"
    : key = "user.id"
  >
    {{ имя пользователя }}
  </li>
</ul>
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/> 8 <br data-v-d5cc771c=""/></p><p data-v-d5cc771c=""> В качестве альтернативы мы можем использовать тег <code data-v-d5cc771c=""> <template> </code> с <code data-v-d5cc771c=""> v-for </code>, чтобы обернуть элемент <code data-v-d5cc771c=""><li> </code>:</p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> <ul>
  <template v-for = "user in users": key = "user.id ">
    <li v-if = "user.isActive">
      {{ имя пользователя }}
    </li>
  </template>
</ul>
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/></p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D0%BB%D0%BE%D1%85%D0%BE-3"></span> Плохо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> <ul>
  <Ли
    v-for = "пользователь среди пользователей"
    v-if = "user.isActive"
    : key = "user.id"
  >
    {{ имя пользователя }}
  </li>
</ul>
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/> 8 <br data-v-d5cc771c=""/> 9 <br data-v-d5cc771c=""/></p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%A5%D0%BE%D1%80%D0%BE%D1%88%D0%BE-3"></span> Хорошо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> <ul>
  <Ли
    v-for = "пользователь в активных пользователях"
    : key = "user.я бы"
  >
    {{ имя пользователя }}
  </li>
</ul>
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/> 8 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> <ul>
  <template v-for = "user in users": key = "user.id">
    <li v-if = "user.isActive">
      {{ имя пользователя }}
    </li>
  </template>
</ul>
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/></p><h4 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9E%D0%B1%D0%BB%D0%B0%D1%81%D1%82%D1%8C_%D0%B2%D0%B8%D0%B4%D0%B8%D0%BC%D0%BE%D1%81%D1%82%D0%B8_%D1%81%D1%82%D0%B8%D0%BB%D1%8F_%D0%BA%D0%BE%D0%BC%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%82%D0%B0"></span> Область видимости стиля компонента <span class="ez-toc-section-end"></span></h4><sup data-p="a" data-v-d5cc771c=""> обязательно </sup></h4><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Для приложений стили в компоненте верхнего уровня <code data-v-d5cc771c=""> App </code> и в компонентах макета могут быть глобальными, но все остальные компоненты всегда должны быть в области видимости.</strong></p><p data-v-d5cc771c=""> Это актуально только для однофайловых компонентов. <em data-v-d5cc771c="">, а не </em>, требует, чтобы использовался атрибут </code> с областью действия <code data-v-d5cc771c=""> (открывается в новом окне). Определение объема может осуществляться с помощью модулей CSS (открывается в новом окне), стратегии на основе классов, такой как BEM (открывается в новом окне), или другой библиотеки / соглашения.</p><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Библиотеки компонентов, однако, должны предпочесть стратегию на основе классов вместо использования атрибута </code> с областью действия <code data-v-d5cc771c="">. </strong></p><p data-v-d5cc771c=""> Это упрощает переопределение внутренних стилей, с удобочитаемыми именами классов, которые не имеют слишком высокой специфичности, но все же очень маловероятны, чтобы привести к конфликту.</p> Подробное объяснение<p data-v-d5cc771c=""> Если вы разрабатываете большой проект, работаете с другими разработчиками или иногда включаете сторонний HTML / CSS (например, из Auth0), согласованная область видимости гарантирует, что ваши стили применяются только к тем компонентам, для которых они предназначены.</p><p data-v-d5cc771c=""> За пределами атрибута </code> с областью действия <code data-v-d5cc771c=""> использование уникальных имен классов может помочь гарантировать, что сторонний CSS не применяется к вашему собственному HTML. Например, во многих проектах используются имена классов <code data-v-d5cc771c=""> button </code>, <code data-v-d5cc771c=""> btn </code> или <code data-v-d5cc771c=""> icon </code>, поэтому, даже если не используется такая стратегия, как БЭМ, добавление префикса для конкретного приложения и / или компонента (e.г. <code data-v-d5cc771c=""> ButtonClose-icon </code>) может обеспечить некоторую защиту.</p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D0%BB%D0%BE%D1%85%D0%BE-4"></span> Плохо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> <шаблон>
  <button> × </button>
</template>

<стиль>
.btn-close {
  цвет фона: красный;
}
</style>
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/> 8 <br data-v-d5cc771c=""/> 9 <br data-v-d5cc771c=""/></p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%A5%D0%BE%D1%80%D0%BE%D1%88%D0%BE-4"></span> Хорошо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> <шаблон>
  <button> × </button>
</template>


<область действия стиля>
.кнопка {
  граница: нет;
  радиус границы: 2 пикселя;
}

.button-close {
  цвет фона: красный;
}
</style>
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/> 8 <br data-v-d5cc771c=""/> 9 <br data-v-d5cc771c=""/> 10 <br data-v-d5cc771c=""/> 11 <br data-v-d5cc771c=""/> 12 <br data-v-d5cc771c=""/> 13 <br data-v-d5cc771c=""/> 14 <br data-v-d5cc771c=""/> 15 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> <шаблон>
  <button: class = "[$ style.button, $ style.buttonClose]"> × </button>
</template>


<модуль стиля>
.кнопка {
  граница: нет;
  радиус границы: 2 пикселя;
}

.buttonClose {
  цвет фона: красный;
}
</style>
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/> 8 <br data-v-d5cc771c=""/> 9 <br data-v-d5cc771c=""/> 10 <br data-v-d5cc771c=""/> 11 <br data-v-d5cc771c=""/> 12 <br data-v-d5cc771c=""/> 13 <br data-v-d5cc771c=""/> 14 <br data-v-d5cc771c=""/> 15 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> <шаблон>
  <button> × </button>
</template>


<стиль>
.c-Button {
  граница: нет;
  радиус границы: 2 пикселя;
}

.c-Button - закрыть {
  цвет фона: красный;
}
</style>
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/> 8 <br data-v-d5cc771c=""/> 9 <br data-v-d5cc771c=""/> 10 <br data-v-d5cc771c=""/> 11 <br data-v-d5cc771c=""/> 12 <br data-v-d5cc771c=""/> 13 <br data-v-d5cc771c=""/> 14 <br data-v-d5cc771c=""/> 15 <br data-v-d5cc771c=""/></p><h4 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%98%D0%BC%D0%B5%D0%BD%D0%B0_%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%BE%D0%B9_%D1%81%D0%BE%D0%B1%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D0%BE%D1%81%D1%82%D0%B8"></span> Имена частной собственности <span class="ez-toc-section-end"></span></h4><sup data-p="a" data-v-d5cc771c=""> Essential </sup></h4><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Использовать частный модуль sc функции недоступны извне. Если это невозможно, всегда используйте префикс <code data-v-d5cc771c=""> $ _ </code> для настраиваемых частных свойств в плагине, миксине и т. Д., Которые не должны считаться общедоступным API.Затем, чтобы избежать конфликтов с кодом других авторов, также включите именованную область (например, <code data-v-d5cc771c=""> $ _yourPluginName_ </code>). </strong></p> Подробное объяснение<p data-v-d5cc771c=""> Vue использует префикс <code data-v-d5cc771c=""> _ </code> для определения своих собственных частных свойств, поэтому использование того же префикса (например, <code data-v-d5cc771c=""> _update </code>) может привести к перезаписи свойства экземпляра. Даже если вы проверяете, а Vue в настоящее время не использует конкретное имя свойства, нет гарантии, что конфликт не возникнет в более поздней версии.</p><p data-v-d5cc771c=""> Что касается префикса <code data-v-d5cc771c=""> $ </code>, его цель в экосистеме Vue - особые свойства экземпляра, которые доступны пользователю, поэтому использование его для <em data-v-d5cc771c=""> частных свойств </em> нецелесообразно.</p><p data-v-d5cc771c=""> Вместо этого мы рекомендуем объединить два префикса в <code data-v-d5cc771c=""> $ _ </code> в качестве соглашения для определяемых пользователем частных свойств, которые гарантируют отсутствие конфликтов с Vue.</p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D0%BB%D0%BE%D1%85%D0%BE-5"></span> Плохо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> const myGreatMixin = {
  
  методы: {
    Обновить() {
      
    }
  }
}
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/> 8 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> const myGreatMixin = {
  
  методы: {
    _Обновить() {
      
    }
  }
}
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/> 8 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> const myGreatMixin = {
  
  методы: {
    $ update () {
      
    }
  }
}
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/> 8 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> const myGreatMixin = {
  
  методы: {
    $ _update () {
      
    }
  }
}
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/> 8 <br data-v-d5cc771c=""/></p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%A5%D0%BE%D1%80%D0%BE%D1%88%D0%BE-5"></span> Хорошо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> const myGreatMixin = {
  
  методы: {
    $ _myGreatMixin_update () {
      
    }
  }
}
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/> 8 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c="">
const myGreatMixin = {
  
  методы: {
    publicMethod () {
      
      myPrivateFunction ()
    }
  }
}

function myPrivateFunction () {
  
}

экспорт по умолчанию myGreatMixin
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/> 8 <br data-v-d5cc771c=""/> 9 <br data-v-d5cc771c=""/> 10 <br data-v-d5cc771c=""/> 11 <br data-v-d5cc771c=""/> 12 <br data-v-d5cc771c=""/> 13 <br data-v-d5cc771c=""/> 14 <br data-v-d5cc771c=""/> 15 <br data-v-d5cc771c=""/> 16 <br data-v-d5cc771c=""/></p><h3 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D1%80%D0%B0%D0%B2%D0%B8%D0%BB%D0%B0_%D0%BF%D1%80%D0%B8%D0%BE%D1%80%D0%B8%D1%82%D0%B5%D1%82%D0%B0_B_%D0%9D%D0%B0%D1%81%D1%82%D0%BE%D1%8F%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D0%BE_%D1%80%D0%B5%D0%BA%D0%BE%D0%BC%D0%B5%D0%BD%D0%B4%D1%83%D0%B5%D1%82%D1%81%D1%8F"></span> Правила приоритета B: Настоятельно рекомендуется <span class="ez-toc-section-end"></span></h3><pre data-v-d5cc771c="">253 Файлы компонентов </sup> </h4> <p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Всякий раз, когда доступна система сборки для объединения файлов, каждый компонент должен находиться в своем собственном файле.</strong> </p> <p data-v-d5cc771c=""> Это поможет вам быстрее найти компонент, когда вам нужно отредактировать его или посмотреть, как его использовать. </p> <h5 data-v-d5cc771c=""><span class="ez-toc-section" id="Bad"></span> Bad <span class="ez-toc-section-end"></span></h5> <pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> app.component ('TodoList', {
  
})

app.component ('TodoItem', {
  
})
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/></p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%A5%D0%BE%D1%80%D0%BE%D1%88%D0%BE-6"></span> Хорошо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> компонентов /
| - TodoList.js
| - TodoItem.js
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> компонентов /
| - TodoList.vue
| - TodoItem.vue
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/></p><h4 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9E%D0%B1%D0%BE%D0%BB%D0%BE%D1%87%D0%BA%D0%B0_%D0%B8%D0%BC%D0%B5%D0%BD%D0%B8_%D1%84%D0%B0%D0%B9%D0%BB%D0%B0_%D0%BE%D0%B4%D0%BD%D0%BE%D1%84%D0%B0%D0%B9%D0%BB%D0%BE%D0%B2%D0%BE%D0%B3%D0%BE_%D0%BA%D0%BE%D0%BC%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%82%D0%B0"></span> Оболочка имени файла однофайлового компонента <span class="ez-toc-section-end"></span></h4><sup data-p="b" data-v-d5cc771c=""> настоятельно рекомендуется </sup></h4><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Имена файлов однофайловых компонентов всегда должны быть в формате PascalCase или всегда в формате kebab.</strong></p><p data-v-d5cc771c=""> PascalCase лучше всего работает с автозаполнением в редакторах кода, поскольку он согласуется с тем, как мы ссылаемся на компоненты в JS (X) и шаблонах, где это возможно. Однако имена файлов со смешанным регистром иногда могут создавать проблемы в файловых системах без учета регистра, поэтому kebab-case также вполне приемлем.</p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D0%BB%D0%BE%D1%85%D0%BE-6"></span> Плохо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> компонентов /
| - mycomponent.vue
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> компонентов /
| - myComponent.vue
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/></p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%A5%D0%BE%D1%80%D0%BE%D1%88%D0%BE-7"></span> Хорошо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> компонентов /
| - MyComponent.vue
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> компонентов /
| - my-component.vue
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/></p><h4 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9D%D0%B0%D0%B7%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F_%D0%B1%D0%B0%D0%B7%D0%BE%D0%B2%D1%8B%D1%85_%D0%BA%D0%BE%D0%BC%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%82%D0%BE%D0%B2"></span> Названия базовых компонентов <span class="ez-toc-section-end"></span></h4><sup data-p="b" data-v-d5cc771c=""> настоятельно рекомендуется </sup></h4><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Базовые компоненты (также известные как презентационные, тупые или чистые компоненты), которые применяют стиль и соглашения для конкретного приложения, должны начинаться с определенного префикса, например <code data-v-d5cc771c=""> База </code>, приложение <code data-v-d5cc771c=""> </code> или <code data-v-d5cc771c=""> V </code>. </strong></p> Подробное объяснение<p data-v-d5cc771c=""> Эти компоненты закладывают основу для согласованного стиля и поведения в вашем приложении.Они могут содержать только <strong data-v-d5cc771c="">, </strong>:</p><ul data-v-d5cc771c=""><li data-v-d5cc771c=""> HTML-элементов,</li><li data-v-d5cc771c=""> других базовых компонентов и</li><li data-v-d5cc771c=""> сторонних компонентов пользовательского интерфейса.</li></ul><p data-v-d5cc771c=""> Но они <strong data-v-d5cc771c=""> никогда не будут содержать </strong> глобального состояния (например, из магазина Vuex).</p><p data-v-d5cc771c=""> Их имена часто включают имя элемента, который они заключают в оболочку (например, <code data-v-d5cc771c=""> BaseButton </code>, <code data-v-d5cc771c=""> BaseTable </code>), если не существует элемента для их конкретной цели (например, <code data-v-d5cc771c=""> BaseIcon </code>). Если вы создаете аналогичные компоненты для более конкретного контекста, они почти всегда будут использовать эти компоненты (например,г. <code data-v-d5cc771c=""> BaseButton </code> может использоваться в <code data-v-d5cc771c=""> ButtonSubmit </code>).</p><p data-v-d5cc771c=""> Некоторые преимущества этого соглашения:</p><ul data-v-d5cc771c=""><li data-v-d5cc771c=""><p data-v-d5cc771c=""> При организации в редакторах в алфавитном порядке все базовые компоненты вашего приложения перечислены вместе, что упрощает их идентификацию.</p></li><li data-v-d5cc771c=""><p data-v-d5cc771c=""> Поскольку имена компонентов всегда должны состоять из нескольких слов, это соглашение избавляет вас от необходимости выбирать произвольный префикс для простых оболочек компонентов (например, <code data-v-d5cc771c=""> MyButton </code>, <code data-v-d5cc771c=""> VueButton </code>).</p></li><li data-v-d5cc771c=""><p data-v-d5cc771c=""> Поскольку эти компоненты используются очень часто, вы можете просто сделать их глобальными, а не импортировать их повсюду. Префикс делает это возможным с Webpack:</p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> const requireComponent = require.context ("./ src", true, /Base[A-Zpting\w+\.(vue|js)$/)
requireComponent.keys (). forEach (функция (имя_файла) {
  пусть baseComponentConfig = requireComponent (имя_файла)
  baseComponentConfig = baseComponentConfig.default || baseComponentConfig
  const baseComponentName = baseComponentConfig.. + \ //, '')
      .replace (/ \. \ w + $ /, '')
  )
  app.component (baseComponentName, baseComponentConfig)
})
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/> 8 <br data-v-d5cc771c=""/> 9 <br data-v-d5cc771c=""/> 10 <br data-v-d5cc771c=""/> 11 <br data-v-d5cc771c=""/></p></li></ul><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D0%BB%D0%BE%D1%85%D0%BE-7"></span> Плохо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> компоненты /
| - MyButton.vue
| - VueTable.vue
| - Icon.vue
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/></p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%A5%D0%BE%D1%80%D0%BE%D1%88%D0%BE-8"></span> Хорошо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> компонентов /
| - BaseButton.vue
| - BaseTable.vue
| - BaseIcon.vue
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> компонентов /
| - AppButton.vue
| - AppTable.vue
| - AppIcon.vue
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> компонентов /
| - VButton.vue
| - VTable.vue
| - VIcon.vue
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/></p><h4 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%98%D0%BC%D0%B5%D0%BD%D0%B0_%D0%BA%D0%BE%D0%BC%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%82%D0%BE%D0%B2_%D1%81_%D0%BE%D0%B4%D0%BD%D0%B8%D0%BC_%D1%8D%D0%BA%D0%B7%D0%B5%D0%BC%D0%BF%D0%BB%D1%8F%D1%80%D0%BE%D0%BC"></span> Имена компонентов с одним экземпляром <span class="ez-toc-section-end"></span></h4><sup data-p="b" data-v-d5cc771c=""> настоятельно рекомендуется </sup></h4><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Компоненты, которые должны иметь только один активный экземпляр, должны начинаться с префикса <code data-v-d5cc771c="">, чтобы обозначить, что может быть только один. </strong></p><p data-v-d5cc771c=""> Это не означает, что компонент используется только на одной странице, но он будет использоваться только один раз <em data-v-d5cc771c=""> на страницу </em>.Эти компоненты никогда не принимают никаких реквизитов, поскольку они относятся к вашему приложению, а не к их контексту в вашем приложении. Если вы обнаружите необходимость добавить реквизиты, это хороший признак того, что на самом деле это компонент многократного использования, который используется только один раз на странице <em data-v-d5cc771c="">, а сейчас </em>.</p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D0%BB%D0%BE%D1%85%D0%BE-8"></span> Плохо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> компонентов /
| - Heading.vue
| - MySidebar.vue
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/></p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%A5%D0%BE%D1%80%D0%BE%D1%88%D0%BE-9"></span> Хорошо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> компонентов /
| - TheHeading.vue
| - TheSidebar.vue
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/></p><h4 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%A1%D0%B8%D0%BB%D1%8C%D0%BD%D0%BE_%D1%81%D0%B2%D1%8F%D0%B7%D0%B0%D0%BD%D0%BD%D1%8B%D0%B5_%D0%B8%D0%BC%D0%B5%D0%BD%D0%B0_%D0%BA%D0%BE%D0%BC%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%82%D0%BE%D0%B2"></span> Сильно связанные имена компонентов <span class="ez-toc-section-end"></span></h4><sup data-p="b" data-v-d5cc771c=""> настоятельно рекомендуется </sup></h4><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Дочерние компоненты, которые тесно связаны со своими родительскими, должны включать имя родительского компонента в качестве префикса.</strong></p><p data-v-d5cc771c=""> Если компонент имеет смысл только в контексте единственного родительского компонента, эта связь должна быть очевидна в его имени. Поскольку редакторы обычно упорядочивают файлы в алфавитном порядке, эти связанные файлы также хранятся рядом друг с другом.</p> Подробное объяснение<p data-v-d5cc771c=""> У вас может возникнуть соблазн решить эту проблему, вложив дочерние компоненты в каталоги, названные в честь их родительских. Например:</p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> компонентов /
| - TodoList /
   | - Товар /
      | - index.vue
      | - Кнопка.vue
   | - index.vue
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/></p><p data-v-d5cc771c=""> или:</p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> компонентов /
| - TodoList /
   | - Товар /
      | - Button.vue
   | - Item.vue
| - TodoList.vue
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/></p><p data-v-d5cc771c=""> Это не рекомендуется, так как в результате получается:</p><ul data-v-d5cc771c=""><li data-v-d5cc771c=""> Многие файлы с похожими именами затрудняют быстрое переключение файлов в редакторах кода.</li><li data-v-d5cc771c=""> Множество вложенных подкаталогов, что увеличивает время, необходимое для просмотра компонентов на боковой панели редактора.</li></ul><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D0%BB%D0%BE%D1%85%D0%BE-9"></span> Плохо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> компонентов /
| - TodoList.vue
| - TodoItem.vue
| - TodoButton.vue
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> компонентов /
| - SearchSidebar.vue
| - NavigationForSearchSidebar.vue
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/></p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%A5%D0%BE%D1%80%D0%BE%D1%88%D0%BE-10"></span> Хорошо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> компонентов /
| - TodoList.vue
| - TodoListItem.vue
| - TodoListItemButton.vue
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> компонентов /
| - SearchSidebar.vue
| - SearchSidebarNavigation.vue
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/></p><h4 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D0%BE%D1%80%D1%8F%D0%B4%D0%BE%D0%BA_%D1%81%D0%BB%D0%BE%D0%B2_%D0%B2_%D0%B8%D0%BC%D0%B5%D0%BD%D0%B0%D1%85_%D0%BA%D0%BE%D0%BC%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%82%D0%BE%D0%B2"></span> Порядок слов в именах компонентов <span class="ez-toc-section-end"></span></h4><sup data-p="b" data-v-d5cc771c=""> настоятельно рекомендуется </sup></h4><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Имена компонентов должны начинаться со слов высшего уровня (часто самых общих) и заканчиваться описательными модифицирующими словами. </strong></p> Подробное объяснение<p data-v-d5cc771c=""> Вы ​​можете спросить:</p><blockquote data-v-d5cc771c=""><p data-v-d5cc771c=""> «Зачем нам заставлять имена компонентов использовать менее естественный язык?»</p></blockquote><p data-v-d5cc771c=""> В естественном английском прилагательные и другие дескрипторы обычно появляются перед существительными, в то время как исключения требуют соединительных слов.Например:</p><ul data-v-d5cc771c=""><li data-v-d5cc771c=""> Кофе <em data-v-d5cc771c=""> с молоком </em></li><li data-v-d5cc771c=""> Суп <em data-v-d5cc771c=""> дня </em></li><li data-v-d5cc771c=""> Посетитель <em data-v-d5cc771c=""> в музей </em></li></ul><p data-v-d5cc771c=""> Вы ​​можете определенно включить эти соединительные слова в названия компонентов, если хотите, но порядок по-прежнему важно.</p><p data-v-d5cc771c=""> Также обратите внимание, что <strong data-v-d5cc771c="">, который считается «высшим уровнем», будет контекстным для вашего приложения </strong>. Например, представьте себе приложение с формой поиска. Он может включать такие компоненты, как этот:</p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> компонентов /
| - ClearSearchButton.vue
| - ExcludeFromSearchInput.vue
| - LaunchOnStartupCheckbox.vue
| - RunSearchButton.vue
| - SearchInput.vue
| - ТерминыCheckbox.vue
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/></p><p data-v-d5cc771c=""> Как вы могли заметить, довольно сложно увидеть, какие компоненты специфичны для поиска. Теперь переименуем компоненты по правилу:</p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> компонентов /
| - SearchButtonClear.vue
| - SearchButtonRun.vue
| - SearchInputExcludeGlob.vue
| - SearchInputQuery.vue
| - НастройкиCheckboxLaunchOnStartup.vue
| - SettingsCheckboxTerms.vue
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/></p><p data-v-d5cc771c=""> Поскольку редакторы обычно организуют файлы в алфавитном порядке, все важные взаимосвязи между компонентами теперь очевидны с первого взгляда.</p><p data-v-d5cc771c=""> У вас может возникнуть соблазн решить эту проблему по-другому, вложив все компоненты поиска в каталог «search», а затем все компоненты настроек в каталог «settings». Мы рекомендуем рассматривать этот подход только в очень больших приложениях (например.г. 100+ компонентов) по следующим причинам:</p><ul data-v-d5cc771c=""><li data-v-d5cc771c=""> Обычно перемещение по вложенным подкаталогам занимает больше времени, чем прокрутка одного каталога компонентов <code data-v-d5cc771c=""> </code>.</li><li data-v-d5cc771c=""> Конфликты имен (например, несколько компонентов <code data-v-d5cc771c=""> ButtonDelete.vue </code>) затрудняют быстрый переход к определенному компоненту в редакторе кода.</li><li data-v-d5cc771c=""> Рефакторинг становится более трудным, потому что поиска и замены часто недостаточно для обновления относительных ссылок на перемещенный компонент.</li></ul><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D0%BB%D0%BE%D1%85%D0%BE-10"></span> Плохо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> компонентов /
| - ClearSearchButton.vue
| - ExcludeFromSearchInput.vue
| - LaunchOnStartupCheckbox.vue
| - RunSearchButton.vue
| - SearchInput.vue
| - ТерминыCheckbox.vue
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/></p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%A5%D0%BE%D1%80%D0%BE%D1%88%D0%BE-11"></span> Хорошо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> компонентов /
| - SearchButtonClear.vue
| - SearchButtonRun.vue
| - SearchInputQuery.vue
| - SearchInputExcludeGlob.vue
| - SettingsCheckboxTerms.vue
| - НастройкиCheckboxLaunchOnStartup.vue
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/></p><h4 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%A1%D0%B0%D0%BC%D0%BE%D0%B7%D0%B0%D0%BA%D1%80%D1%8B%D0%B2%D0%B0%D1%8E%D1%89%D0%B8%D0%B5%D1%81%D1%8F_%D0%BA%D0%BE%D0%BC%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%82%D1%8B"></span> Самозакрывающиеся компоненты <span class="ez-toc-section-end"></span></h4><sup data-p="b" data-v-d5cc771c=""> настоятельно рекомендуется </sup></h4><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Компоненты без содержимого должны быть самозакрывающимися в однофайловых компонентах, строковых шаблонах и JSX - но никогда в шаблонах DOM. </strong></p><p data-v-d5cc771c=""> Компоненты, которые закрываются самостоятельно, сообщают, что у них не только нет содержимого, но <strong data-v-d5cc771c=""> означает, что </strong> не имеет содержимого. В этом разница между пустой страницей в книге и страницей с надписью «Эта страница намеренно оставлена ​​пустой.«Ваш код также чище без ненужного закрывающего тега.</p><p data-v-d5cc771c=""> К сожалению, HTML не позволяет настраиваемым элементам быть самозакрывающимися - только официальные« пустые »элементы (открывает новое окно). Вот почему эта стратегия возможна только тогда, когда Vue компилятор шаблона может достичь шаблона до DOM, а затем передать HTML-код, соответствующий спецификации DOM.</p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D0%BB%D0%BE%D1%85%D0%BE-11"></span> Плохо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c="">
<MyComponent> </MyComponent>
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/></p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%A5%D0%BE%D1%80%D0%BE%D1%88%D0%BE-12"></span> Хорошо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c="">
<my-component> </my-component>
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/></p><h4 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9E%D0%B1%D0%BE%D0%BB%D0%BE%D1%87%D0%BA%D0%B0_%D0%B8%D0%BC%D0%B5%D0%BD_%D0%BA%D0%BE%D0%BC%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%82%D0%BE%D0%B2_%D0%B2_%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD%D0%B0%D1%85"></span> Оболочка имен компонентов в шаблонах <span class="ez-toc-section-end"></span></h4><sup data-p="b" data-v-d5cc771c=""> настоятельно рекомендуется </sup></h4><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> В большинстве проектов имена компонентов всегда должны быть в формате PascalCase в однофайловых компонентах и ​​строковых шаблонах, но в шаблонах DOM - в стиле kebab.</strong></p><p data-v-d5cc771c=""> PascalCase имеет несколько преимуществ перед kebab-case:</p><ul data-v-d5cc771c=""><li data-v-d5cc771c=""> Редакторы могут автоматически заполнять имена компонентов в шаблонах, поскольку PascalCase также используется в JavaScript.</li><li data-v-d5cc771c=""> <code data-v-d5cc771c=""> <MyComponent> </code> более визуально отличается от элемента HTML из одного слова, чем <code data-v-d5cc771c=""> <my-component> </code>, потому что существует два различия символа (две заглавные буквы), а не только один (дефис).</li><li data-v-d5cc771c=""> Если вы используете какие-либо пользовательские элементы, не относящиеся к Vue, в своих шаблонах, например, веб-компонент, PascalCase гарантирует, что ваши компоненты Vue останутся отчетливо видимыми.</li></ul><p data-v-d5cc771c=""> К сожалению, из-за нечувствительности к регистру в HTML шаблоны DOM по-прежнему должны использовать kebab-case.</p><p data-v-d5cc771c=""> Также обратите внимание, что если вы уже вложили значительные средства в kebab-case, согласованность с соглашениями HTML и возможность использовать один и тот же регистр во всех ваших проектах могут быть более важными, чем перечисленные выше преимущества. В таких случаях можно использовать <strong data-v-d5cc771c=""> вездехода для шашлыка. </strong></p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D0%BB%D0%BE%D1%85%D0%BE-12"></span> Плохо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c="">
<MyComponent> </MyComponent>
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/></p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%A5%D0%BE%D1%80%D0%BE%D1%88%D0%BE-13"></span> Хорошо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c="">
<my-component> </my-component>
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/></p><p data-v-d5cc771c=""> ИЛИ</p><pre data-v-d5cc771c=""> <code data-v-d5cc771c="">
<my-component> </my-component>
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/></p><h4 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9E%D0%B1%D0%BE%D0%BB%D0%BE%D1%87%D0%BA%D0%B0_%D0%B8%D0%BC%D0%B5%D0%BD_%D0%BA%D0%BE%D0%BC%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%82%D0%BE%D0%B2_%D0%B2_JS_/_JSX"></span> Оболочка имен компонентов в JS / JSX <span class="ez-toc-section-end"></span></h4><sup data-p="b" data-v-d5cc771c=""> настоятельно рекомендуется </sup></h4><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Имена компонентов в JS / JSX всегда должны быть в формате PascalCase, хотя они могут быть внутри строк в виде шашлыка для более простых приложений, которые используют только глобальные регистрация компонента через приложение <code data-v-d5cc771c="">.компонент </code>. </strong></p> Подробное объяснение<p data-v-d5cc771c=""> В JavaScript PascalCase - это соглашение для классов и конструкторов прототипов - по сути, всего, что может иметь отдельные экземпляры. Компоненты Vue также имеют экземпляры, поэтому имеет смысл также использовать PascalCase. В качестве дополнительного преимущества использование PascalCase в JSX (и шаблонах) позволяет читателям кода легче различать компоненты и элементы HTML.</p><p data-v-d5cc771c=""> Однако для приложений, которые используют <strong data-v-d5cc771c=""> только определения глобальных компонентов </strong> через приложение <code data-v-d5cc771c="">.компонент </code>, мы рекомендуем кебаб-футляр. Причины:</p><ul data-v-d5cc771c=""><li data-v-d5cc771c=""> Глобальные компоненты редко когда-либо упоминаются в JavaScript, поэтому соблюдение соглашения для JavaScript не имеет смысла.</li><li data-v-d5cc771c=""> Эти приложения всегда включают множество шаблонов в DOM, где нужно использовать kebab-case <strong data-v-d5cc771c=""> </strong>.</li></ul><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="Bad-2"></span> Bad <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> app.component ('myComponent', {
  
})
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> импортировать myComponent из './MyComponent.vue '
 </code> </pre><p> 1 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> экспорт по умолчанию {
  name: 'myComponent',
  
}
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> экспорт по умолчанию {
  имя: 'мой-компонент',
  
}
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/></p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%A5%D0%BE%D1%80%D0%BE%D1%88%D0%BE-14"></span> Хорошо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> app.component ('MyComponent', {
  
})
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> app.component ('my-component', {
  
})
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> импортировать MyComponent из './MyComponent.vue '
 </code> </pre><p> 1 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> экспорт по умолчанию {
  имя: 'MyComponent',
  
}
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/></p><h4 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D0%BE%D0%BB%D0%BD%D1%8B%D0%B5_%D0%B8%D0%BC%D0%B5%D0%BD%D0%B0_%D0%BA%D0%BE%D0%BC%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%82%D0%BE%D0%B2"></span> Полные имена компонентов <span class="ez-toc-section-end"></span></h4><sup data-p="b" data-v-d5cc771c=""> настоятельно рекомендуется </sup></h4><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> В именах компонентов следует отдавать предпочтение полным словам, а не сокращениям. </strong></p><p data-v-d5cc771c=""> Автодополнение в редакторах снижает стоимость написания более длинных имен, в то время как ясность, которую они обеспечивают, неоценима. В частности, всегда следует избегать необычных сокращений.</p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D0%BB%D0%BE%D1%85%D0%BE-13"></span> Плохо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> компонентов /
| - SdSettings.vue
| - UProfOpts.vue
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/></p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%A5%D0%BE%D1%80%D0%BE%D1%88%D0%BE-15"></span> Хорошо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> компонентов /
| - StudentDashboardSettings.vue
| - UserProfileOptions.vue
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/></p><h4 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9E%D0%B1%D0%BE%D0%BB%D0%BE%D1%87%D0%BA%D0%B0_%D0%B4%D0%BB%D1%8F_%D0%B8%D0%BC%D0%B5%D0%BD%D0%B8_%D0%BF%D1%80%D0%BE%D0%BF%D1%83%D1%81%D0%BA%D0%B0"></span> Оболочка для имени пропуска <span class="ez-toc-section-end"></span></h4><sup data-p="b" data-v-d5cc771c=""> настоятельно рекомендуется </sup></h4><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> В именах опор всегда должен использоваться camelCase во время объявления, а в шаблонах и JSX - kebab-case. </strong></p><p data-v-d5cc771c=""> Мы просто следуем правилам каждого языка.В JavaScript camelCase более естественен. Внутри HTML есть kebab-case.</p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D0%BB%D0%BE%D1%85%D0%B8%D0%B5"></span> Плохие <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> опоры: {
  'welcome-text': Строка
}
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> <WelcomeMessage welcomeText = "hi" />
 </code> </pre><p> 1 <br data-v-d5cc771c=""/></p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%A5%D0%BE%D1%80%D0%BE%D1%88%D0%B5%D0%B5"></span> Хорошее <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> опоры: {
  welcomeText: Строка
}
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> <WelcomeMessage welcome-text = "hi" />
 </code> </pre><p> 1 <br data-v-d5cc771c=""/></p><h4 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%AD%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D1%8B_%D1%81_%D0%BD%D0%B5%D1%81%D0%BA%D0%BE%D0%BB%D1%8C%D0%BA%D0%B8%D0%BC%D0%B8_%D0%B0%D1%82%D1%80%D0%B8%D0%B1%D1%83%D1%82%D0%B0%D0%BC%D0%B8"></span> Элементы с несколькими атрибутами <span class="ez-toc-section-end"></span></h4><sup data-p="b" data-v-d5cc771c=""> настоятельно рекомендуется </sup></h4><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Элементы с несколькими атрибутами должны занимать несколько строк, по одному атрибуту на строку.</strong></p><p data-v-d5cc771c=""> В JavaScript разделение объектов с несколькими свойствами на несколько строк широко считается хорошим соглашением, поскольку его намного легче читать. Наши шаблоны и JSX заслуживают того же внимания.</p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D0%BB%D0%BE%D1%85%D0%BE-14"></span> Плохо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> <img class="lazy lazy-hidden" src = "https://vuejs.org/images/logo.png" alt = "Vue Logo"><noscript><img src = "https://vuejs.org/images/logo.png" alt = "Vue Logo"></noscript>
 </code> </pre><p> 1 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> <MyComponent foo = "a" bar = "b" baz = "c" />
 </code> </pre><p> 1 <br data-v-d5cc771c=""/></p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%A5%D0%BE%D1%80%D0%BE%D1%88%D0%BE-16"></span> Хорошо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> <noscript><img class="lazy lazy-hidden"
  src = "https: // vuejs.org / images / logo.png "
  alt = "Логотип Vue"
></noscript><img class="lazyload lazy lazy-hidden"
  src = "https: // vuejs.org / images / logo.png "
  alt = "Логотип Vue"
><noscript><img
  src = "https: // vuejs.org / images / logo.png "
  alt = "Логотип Vue"
></noscript>
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> <MyComponent
  foo = "а"
  bar = "b"
  baz = "c"
/>
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/></p><h4 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D1%80%D0%BE%D1%81%D1%82%D1%8B%D0%B5_%D0%B2%D1%8B%D1%80%D0%B0%D0%B6%D0%B5%D0%BD%D0%B8%D1%8F_%D0%B2_%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD%D0%B0%D1%85"></span> Простые выражения в шаблонах <span class="ez-toc-section-end"></span></h4><sup data-p="b" data-v-d5cc771c=""> настоятельно рекомендуется </sup></h4><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Шаблоны компонентов должны включать только простые выражения, а более сложные выражения преобразованы в вычисляемые свойства или методы. </strong></p><p data-v-d5cc771c=""> Сложные выражения в ваших шаблонах делают их менее декларативными.Мы должны стремиться описать <em data-v-d5cc771c=""> то, что должно появиться </em>, а не <em data-v-d5cc771c="">, как </em> мы вычисляем это значение. Вычисленные свойства и методы также позволяют повторно использовать код.</p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D0%BB%D0%BE%D1%85%D0%BE-15"></span> Плохо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> {{
  fullName.split ('') .map ((word) => {
    вернуть слово [0] .toUpperCase () + word.slice (1)
  }).присоединиться(' ')
}}
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/></p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%A5%D0%BE%D1%80%D0%BE%D1%88%D0%BE-17"></span> Хорошо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c="">
{{normalizedFullName}}
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c="">
вычислено: {
  normalizedFullName () {
    верни это.fullName.split ('')
      .map (word => word [0] .toUpperCase () + word.slice (1))
      .присоединиться(' ')
  }
}
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/> 8 <br data-v-d5cc771c=""/></p><h4 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D1%80%D0%BE%D1%81%D1%82%D1%8B%D0%B5_%D0%B2%D1%8B%D1%87%D0%B8%D1%81%D0%BB%D1%8F%D0%B5%D0%BC%D1%8B%D0%B5_%D1%81%D0%B2%D0%BE%D0%B9%D1%81%D1%82%D0%B2%D0%B0"></span> Простые вычисляемые свойства <span class="ez-toc-section-end"></span></h4><sup data-p="b" data-v-d5cc771c=""> настоятельно рекомендуется </sup></h4><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Сложные вычисляемые свойства следует разделить на как можно больше простых свойств. </strong></p> Подробное объяснение<p data-v-d5cc771c=""> Более простые, хорошо названные вычисляемые свойства:</p><ul data-v-d5cc771c=""><li data-v-d5cc771c=""><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Легче тестировать </strong></p><p data-v-d5cc771c=""> Когда каждое вычисляемое свойство содержит только очень простое выражение с очень небольшим количеством зависимостей, гораздо проще написать тесты, подтверждающие, что оно работает правильно.</p></li><li data-v-d5cc771c=""><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Легче читать </strong></p><p data-v-d5cc771c=""> Упрощение вычисляемых свойств заставляет вас давать каждому значению описательное имя, даже если оно не используется повторно. Это позволяет другим разработчикам (и вам в будущем) сосредоточиться на коде, который им небезразличен, и понять, что происходит.</p></li><li data-v-d5cc771c=""><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Более адаптируется к изменяющимся требованиям </strong></p><p data-v-d5cc771c=""> Любое значение, которому можно присвоить имя, может быть полезно для представления. Например, мы можем решить отобразить сообщение, сообщающее пользователю, сколько денег он сэкономил.Мы также можем решить рассчитать налог с продаж, но, возможно, отобразить его отдельно, а не как часть окончательной цены.</p><p data-v-d5cc771c=""> Небольшие специализированные вычисляемые свойства делают меньше предположений о том, как будет использоваться информация, поэтому требуют меньше рефакторинга при изменении требований.</p></li></ul><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D0%BB%D0%BE%D1%85%D0%BE-16"></span> Плохо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> вычислено: {
  цена() {
    const basePrice = this.manufactureCost / (1 - this.profitMargin)
    возвращение (
      базисная цена -
      basePrice * (this.discountPercent || 0)
    )
  }
}
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/> 8 <br data-v-d5cc771c=""/> 9 <br data-v-d5cc771c=""/></p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%A5%D0%BE%D1%80%D0%BE%D1%88%D0%BE-18"></span> Хорошо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> вычислено: {
  базисная цена() {
    верни это.ManufacturerCost / (1 - this.profitMargin)
  },

  скидка() {
    вернуть this.basePrice * (this.discountPercent || 0)
  },

  finalPrice () {
    вернуть this.basePrice - this.discount
  }
}
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/> 8 <br data-v-d5cc771c=""/> 9 <br data-v-d5cc771c=""/> 10 <br data-v-d5cc771c=""/> 11 <br data-v-d5cc771c=""/> 12 <br data-v-d5cc771c=""/> 13 <br data-v-d5cc771c=""/></p><h4 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%97%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D1%8F_%D0%B0%D1%82%D1%80%D0%B8%D0%B1%D1%83%D1%82%D0%BE%D0%B2_%D0%B2_%D0%BA%D0%B0%D0%B2%D1%8B%D1%87%D0%BA%D0%B0%D1%85"></span> Значения атрибутов в кавычках <span class="ez-toc-section-end"></span></h4><sup data-p="b" data-v-d5cc771c=""> настоятельно рекомендуется </sup></h4><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Непустые значения атрибутов HTML всегда должны быть внутри кавычек (одинарные или двойные, в зависимости от того, что не используется в JS).</strong></p><p data-v-d5cc771c=""> Хотя значения атрибутов без пробелов не обязательно должны заключаться в кавычки в HTML, эта практика часто приводит к <em data-v-d5cc771c=""> избеганию </em> пробелов, что делает значения атрибутов менее читаемыми.</p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D0%BB%D0%BE%D1%85%D0%BE-17"></span> Плохо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> <AppSidebar: style = {width: sidebarWidth + 'px'}>
 </code> </pre><p> 1 <br data-v-d5cc771c=""/></p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%A5%D0%BE%D1%80%D0%BE%D1%88%D0%BE-19"></span> Хорошо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> <AppSidebar: style = "{width: sidebarWidth + 'px'}">
 </code> </pre><p> 1 <br data-v-d5cc771c=""/></p><h4 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%A1%D0%BE%D0%BA%D1%80%D0%B0%D1%89%D0%B5%D0%BD%D0%B8%D1%8F_%D0%B4%D0%B8%D1%80%D0%B5%D0%BA%D1%82%D0%B8%D0%B2%D1%8B"></span> Сокращения директивы <span class="ez-toc-section-end"></span></h4><sup data-p="b" data-v-d5cc771c=""> настоятельно рекомендуется </sup></h4><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Сокращения директивы (<code data-v-d5cc771c="">: </code> для <code data-v-d5cc771c=""> v-bind: </code>, <code data-v-d5cc771c=""> @ </code> для <code data-v-d5cc771c=""> v-on: </code> и <code data-v-d5cc771c=""> # </code> v-slot для <em>25 ) следует использовать всегда или никогда.</strong></p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D0%BB%D0%BE%D1%85%D0%BE-18"></span> Плохо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> <ввод
  v-bind: value = "newTodoText"
  : placeholder = "newTodoInstructions"
>
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> <вход
  v-on: input = "onInput"
  @ focus = "onFocus"
>
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> <шаблон v-slot: header>
   <h2><span class="ez-toc-section" id="%D0%97%D0%B4%D0%B5%D1%81%D1%8C_%D0%BC%D0%BE%D0%B6%D0%B5%D1%82_%D0%B1%D1%8B%D1%82%D1%8C_%D0%B7%D0%B0%D0%B3%D0%BE%D0%BB%D0%BE%D0%B2%D0%BE%D0%BA_%D1%81%D1%82%D1%80%D0%B0%D0%BD%D0%B8%D1%86%D1%8B"></span> Здесь может быть заголовок страницы <span class="ez-toc-section-end"></span></h2> 
</template>

<шаблон # нижний колонтитул>
  <p> Вот некоторая контактная информация </p>
</template>
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/></p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%A5%D0%BE%D1%80%D0%BE%D1%88%D0%BE-20"></span> Хорошо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> <ввод
  : value = "newTodoText"
  : placeholder = "newTodoInstructions"
>
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> <вход
  v-bind: value = "newTodoText"
  v-bind: placeholder = "newTodoInstructions"
>
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> <вход
  @ input = "onInput"
  @ focus = "onFocus"
>
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> <вход
  v-on: input = "onInput"
  v-on: focus = "onFocus"
>
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> <шаблон v-slot: header>
   <h2><span class="ez-toc-section" id="%D0%97%D0%B4%D0%B5%D1%81%D1%8C_%D0%BC%D0%BE%D0%B6%D0%B5%D1%82_%D0%B1%D1%8B%D1%82%D1%8C_%D0%B7%D0%B0%D0%B3%D0%BE%D0%BB%D0%BE%D0%B2%D0%BE%D0%BA_%D1%81%D1%82%D1%80%D0%B0%D0%BD%D0%B8%D1%86%D1%8B-2"></span> Здесь может быть заголовок страницы <span class="ez-toc-section-end"></span></h2> 
</template>

<v-слот шаблона: нижний колонтитул>
  <p> Вот некоторая контактная информация </p>
</template>
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> <template #header>
   <h2><span class="ez-toc-section" id="%D0%97%D0%B4%D0%B5%D1%81%D1%8C_%D0%BC%D0%BE%D0%B6%D0%B5%D1%82_%D0%B1%D1%8B%D1%82%D1%8C_%D0%B7%D0%B0%D0%B3%D0%BE%D0%BB%D0%BE%D0%B2%D0%BE%D0%BA_%D1%81%D1%82%D1%80%D0%B0%D0%BD%D0%B8%D1%86%D1%8B-3"></span> Здесь может быть заголовок страницы <span class="ez-toc-section-end"></span></h2> 
</template>

<шаблон # нижний колонтитул>
  <p> Вот некоторая контактная информация </p>
</template>
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/></p><h3 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D1%80%D0%B0%D0%B2%D0%B8%D0%BB%D0%B0_%D0%BF%D1%80%D0%B8%D0%BE%D1%80%D0%B8%D1%82%D0%B5%D1%82%D0%B0_C_%D1%80%D0%B5%D0%BA%D0%BE%D0%BC%D0%B5%D0%BD%D0%B4%D1%83%D0%B5%D1%82%D1%81%D1%8F"></span> Правила приоритета C: рекомендуется <span class="ez-toc-section-end"></span></h3><h4 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D0%BE%D1%80%D1%8F%D0%B4%D0%BE%D0%BA_%D0%BE%D0%BF%D1%86%D0%B8%D0%B9_%D0%BA%D0%BE%D0%BC%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%82%D0%BE%D0%B2_/_%D1%8D%D0%BA%D0%B7%D0%B5%D0%BC%D0%BF%D0%BB%D1%8F%D1%80%D0%BE%D0%B2_%D1%80%D0%B5%D0%BA%D0%BE%D0%BC%D0%B5%D0%BD%D0%B4%D1%83%D0%B5%D1%82%D1%81%D1%8F"></span> Порядок опций компонентов / экземпляров рекомендуется <span class="ez-toc-section-end"></span></h4><sup data-p="c" data-v-d5cc771c=""> </sup></h4><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Опции компонентов / экземпляров следует заказывать последовательно.</strong></p><p data-v-d5cc771c=""> Это порядок по умолчанию, который мы рекомендуем для опций компонентов. Они разделены на категории, поэтому вы будете знать, куда добавлять новые свойства из плагинов.</p><ol data-v-d5cc771c=""><li data-v-d5cc771c=""><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Global Awareness </strong> (требуется знание, выходящее за рамки компонента)</p></li><li data-v-d5cc771c=""><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Параметры компилятора шаблона </strong> (изменяет способ компиляции шаблонов)</p></li><li data-v-d5cc771c=""><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Зависимости шаблона </strong> (активы, используемые в шаблоне)</p></li><li data-v-d5cc771c=""><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Композиция </strong> (объединяет свойства в параметры)</p><ul data-v-d5cc771c=""><li data-v-d5cc771c=""> <code data-v-d5cc771c=""> расширяет </code></li><li data-v-d5cc771c=""> <code data-v-d5cc771c=""> миксинов </code></li><li data-v-d5cc771c=""> <code data-v-d5cc771c=""> обеспечивает ввод </code>/<code data-v-d5cc771c=""> </code></li></ul></li><li data-v-d5cc771c=""><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Интерфейс<h2><span class="ez-toc-section" id="06"></span>06 <span class="ez-toc-section-end"></span></h2> <code data-v-d5cc771c="">9 (интерфейс к компоненту) 9 inheritAttrs </code></li><li data-v-d5cc771c=""> <code data-v-d5cc771c=""> props </code></li><li data-v-d5cc771c=""> <code data-v-d5cc771c=""> испускает </code></li><li data-v-d5cc771c=""> <code data-v-d5cc771c=""> expose </code></li></ul></li><li data-v-d5cc771c=""><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Composition API </strong> (точка входа для использования Composition API)</p></li><li data-v-d5cc771c=""><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> локальное состояние</li><li data-v-d5cc771c=""><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> События </strong> (обратные вызовы, запускаемые реактивными событиями)</p><ul data-v-d5cc771c=""><li data-v-d5cc771c=""> <code data-v-d5cc771c=""> watch </code></li><li data-v-d5cc771c=""> События жизненного цикла (в порядке их вызова)<ul data-v-d5cc771c=""><li data-v-d5cc771c=""> <code data-v-d5cc771c=""> beforeCreate </code></li><li data-v-d5cc771c=""> <code data-v-d5cc771c=""> created </code></li><li data-v-d5cc771c=""> <code data-v-d5cc771c=""> beforeMount </code></li><li data-v-d5cc771c=""> <code data-v-d5cc771c=""> смонтировано </code></li><li data-v-d5cc771c=""> <code data-v-d5cc771c=""> beforeUpdate </code></li><li data-v-d5cc771c=""> <code data-v-d5cc771c=""> обновлено </code></li> </code></li><li data-v-d5cc771c=""> <code data-v-d5cc771c=""> обновлено </code></li> </code></li> <br/> деактивировано </code> </strong></li><li data-v-d5cc771c=""> <code data-v-d5cc771c=""> errorCaptured </code></li><li data-v-d5cc771c=""> <code data-v-d5cc771c=""> renderTracked </code></li><li data-v-d5cc771c=""> <code data-v-d5cc771c=""> renderTriggered </code></li></ul></li></ul></li><li data-v-d5cc771c=""><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Нереактивные свойства </strong> (свойства экземпляра, не зависящие от системы описания реактивности)</p></li><li data-v-d5cc771c=""><p data-v-d5cc771c=""> декларирование рендеринга компонентный вывод)</p></li></ol><h4 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D0%BE%D1%80%D1%8F%D0%B4%D0%BE%D0%BA_%D0%B0%D1%82%D1%80%D0%B8%D0%B1%D1%83%D1%82%D0%BE%D0%B2_%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%B0"></span> Порядок атрибутов элемента <span class="ez-toc-section-end"></span></h4><sup data-p="c" data-v-d5cc771c=""> рекомендуется </sup></h4><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Атрибуты элементов (включая компоненты) должны быть упорядочены последовательно.</strong></p><p data-v-d5cc771c=""> Это порядок по умолчанию, который мы рекомендуем для опций компонентов. Они разделены на категории, поэтому вы будете знать, куда добавлять настраиваемые атрибуты и директивы.</p><ol data-v-d5cc771c=""><li data-v-d5cc771c=""><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Определение </strong> (предоставляет параметры компонента)</p></li><li data-v-d5cc771c=""><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Отображение списка </strong> (создает несколько вариантов одного и того же элемента)</p></li><li data-v-d5cc771c=""><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Условные обозначения </strong> (визуализируется / отображается элемент)</p><ul data-v-d5cc771c=""><li data-v-d5cc771c=""> <code data-v-d5cc771c=""> v-if </code></li><li data-v-d5cc771c=""> <code data-v-d5cc771c=""> v-else-if </code></li><li data-v-d5cc771c=""> <code data-v-d5cc771c=""> v-else </code></li><li data-v-d5cc771c=""> <code data-v-d5cc771c=""> v-show </code></li><li data-v-d5cc771c=""> <code data-v-d5cc771c=""> v-cloak </code></li></ul></li><li data-v-d5cc771c=""><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Модификаторы рендеринга </strong> (изменяет способ рендеринга элемента )</p></li><li data-v-d5cc771c=""><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Global Awareness </strong> (требуется знание помимо компонента)</p></li><li data-v-d5cc771c=""><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Уникальные атрибуты </strong> (атрибуты, требующие уникальных значений)</p></li><li data-v-d5cc771c=""><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Двусторонняя привязка </strong> (объединение привязки и событий)</p></li><li data-v-d5cc771c=""><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Другие атрибуты </strong> (все неуказанные связанные и несвязанные атрибуты)</p></li><li data-v-d5cc771c=""> 90 885 <strong data-v-d5cc771c=""> События </strong> (прослушиватели событий компонента)</p></li><li data-v-d5cc771c=""><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Содержимое </strong> (переопределяет содержимое элемента)</p></li></ol><h4 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D1%83%D1%81%D1%82%D1%8B%D0%B5_%D1%81%D1%82%D1%80%D0%BE%D0%BA%D0%B8_%D0%B2_%D0%BF%D0%B0%D1%80%D0%B0%D0%BC%D0%B5%D1%82%D1%80%D0%B0%D1%85_%D0%BA%D0%BE%D0%BC%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%82%D0%B0_/_%D1%8D%D0%BA%D0%B7%D0%B5%D0%BC%D0%BF%D0%BB%D1%8F%D1%80%D0%B0"></span> Пустые строки в параметрах компонента / экземпляра <span class="ez-toc-section-end"></span></h4><sup data-p="c" data-v-d5cc771c=""> рекомендуется </sup></h4><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Вы можете добавить одну пустую строку между многострочные свойства, особенно если параметры больше не помещаются на экране без прокрутки.</strong></p><p data-v-d5cc771c=""> Когда компоненты начинают казаться тесными или трудночитаемыми, добавление пробелов между многострочными свойствами может облегчить их повторное сканирование. В некоторых редакторах, таких как Vim, такие параметры форматирования также могут упростить навигацию с помощью клавиатуры.</p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%A5%D0%BE%D1%80%D0%BE%D1%88%D0%B8%D0%B5-2"></span> Хорошие <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> опоры: {
  ценность: {
    тип: String,
    требуется: true
  },

  сосредоточено: {
    тип: логический,
    по умолчанию: false
  },

  метка: Строка,
  значок: Строка
},

вычислено: {
  formattedValue () {
    
  },

  inputClasses () {
    
  }
}
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/> 8 <br data-v-d5cc771c=""/> 9 <br data-v-d5cc771c=""/> 10 <br data-v-d5cc771c=""/> 11 <br data-v-d5cc771c=""/> 12 <br data-v-d5cc771c=""/> 13 <br data-v-d5cc771c=""/> 14 <br data-v-d5cc771c=""/> 15 <br data-v-d5cc771c=""/> 16 <br data-v-d5cc771c=""/> 17 <br data-v-d5cc771c=""/> 18 <br data-v-d5cc771c=""/> 19 <br data-v-d5cc771c=""/> 20 <br data-v-d5cc771c=""/> 21 <br data-v-d5cc771c=""/> 22909 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c="">

props: {
  ценность: {
    тип: String,
    требуется: true
  },
  сосредоточено: {
    тип: логический,
    по умолчанию: false
  },
  метка: Строка,
  значок: Строка
},
вычислено: {
  formattedValue () {
    
  },
  inputClasses () {
    
  }
}
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/> 8 <br data-v-d5cc771c=""/> 9 <br data-v-d5cc771c=""/> 10 <br data-v-d5cc771c=""/> 11 <br data-v-d5cc771c=""/> 12 <br data-v-d5cc771c=""/> 13 <br data-v-d5cc771c=""/> 14 <br data-v-d5cc771c=""/> 15 <br data-v-d5cc771c=""/> 16 <br data-v-d5cc771c=""/> 17 <br data-v-d5cc771c=""/> 18 <br data-v-d5cc771c=""/> 19 <br data-v-d5cc771c=""/> 20 <br data-v-d5cc771c=""/> 21 <br data-v-d5cc771c=""/> 22 909 -file component верхний уровень элементов порядка <sup data-p="c" data-v-d5cc771c=""> рекомендуется </sup></h4><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Однофайловые компоненты всегда должны упорядочивать теги <code data-v-d5cc771c=""> <template> ... </template> </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c="">

<template> ... </template>



<template> ... </template>


 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/> 8 <br data-v-d5cc771c=""/> 9 <br data-v-d5cc771c=""/></p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%A5%D0%BE%D1%80%D0%BE%D1%88%D0%BE-21"></span> Хорошо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c="">

<шаблон>... </template>




<template> ... </template>

 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/> 8 <br data-v-d5cc771c=""/> 9 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c="">
<template> ... </template>




<template> ... </template>


 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/> 8 <br data-v-d5cc771c=""/> 9 <br data-v-d5cc771c=""/></p><h3 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D1%80%D0%B0%D0%B2%D0%B8%D0%BB%D0%B0_%D0%BF%D1%80%D0%B8%D0%BE%D1%80%D0%B8%D1%82%D0%B5%D1%82%D0%B0_D_%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D1%83%D0%B9%D1%82%D0%B5_%D1%81_%D0%BE%D1%81%D1%82%D0%BE%D1%80%D0%BE%D0%B6%D0%BD%D0%BE%D1%81%D1%82%D1%8C%D1%8E"></span> Правила приоритета D: используйте с осторожностью <span class="ez-toc-section-end"></span></h3><h4 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%A1%D0%B5%D0%BB%D0%B5%D0%BA%D1%82%D0%BE%D1%80%D1%8B_%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%BE%D0%B2_%D1%81_%D0%BE%D0%B1%D0%BB%D0%B0%D1%81%D1%82%D1%8C%D1%8E_%D0%B4%D0%B5%D0%B9%D1%81%D1%82%D0%B2%D0%B8%D1%8F"></span> Селекторы элементов с областью действия <span class="ez-toc-section-end"></span></h4><code data-v-d5cc771c=""> </code> <sup data-p="d" data-v-d5cc771c=""> следует использовать с осторожностью </sup></h4><p data-v-d5cc771c=""> избежать с <code data-v-d5cc771c=""> с областью действия </code>.</strong></p><p data-v-d5cc771c=""> Предпочитать селекторы классов селекторам элементов в стилях <code data-v-d5cc771c=""> с областью действия </code>, потому что большое количество селекторов элементов выполняется медленно.</p> Подробное объяснение<p data-v-d5cc771c=""> Для определения стилей Vue добавляет уникальный атрибут к элементам компонента, например <code data-v-d5cc771c=""> data-v-f3f3eg9 </code>. Затем селекторы изменяются так, что выбираются только совпадающие элементы с этим атрибутом (например, кнопка <code data-v-d5cc771c=""> [data-v-f3f3eg9] </code>).</p><p data-v-d5cc771c=""> Проблема в том, что большое количество селекторов элемент-атрибут (например,г. Кнопка <code data-v-d5cc771c=""> [data-v-f3f3eg9] </code>) будет значительно медленнее, чем селекторы атрибутов класса (например, <code data-v-d5cc771c=""> .btn-close [data-v-f3f3eg9] </code>), поэтому по возможности следует отдавать предпочтение селекторам классов.</p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D0%BB%D0%BE%D1%85%D0%BE-20"></span> Плохо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> <шаблон>
  <button> × </button>
</template>

<область действия стиля>
кнопка {
  цвет фона: красный;
}
</style>
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/> 8 <br data-v-d5cc771c=""/> 9 <br data-v-d5cc771c=""/></p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%A5%D0%BE%D1%80%D0%BE%D1%88%D0%BE-22"></span> Хорошо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> <шаблон>
  <button> × </button>
</template>

<область действия стиля>
.btn-close {
  цвет фона: красный;
}
</style>
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/> 8 <br data-v-d5cc771c=""/> 9 <br data-v-d5cc771c=""/></p><h4 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9D%D0%B5%D1%8F%D0%B2%D0%BD%D0%B0%D1%8F_%D1%81%D0%B2%D1%8F%D0%B7%D1%8C_%D0%BC%D0%B5%D0%B6%D0%B4%D1%83_%D1%80%D0%BE%D0%B4%D0%B8%D1%82%D0%B5%D0%BB%D1%8F%D0%BC%D0%B8_%D0%B8_%D0%B4%D0%B5%D1%82%D1%8C%D0%BC%D0%B8"></span> Неявная связь между родителями и детьми <span class="ez-toc-section-end"></span></h4><sup data-p="d" data-v-d5cc771c=""> Используйте с осторожностью из <code data-v-d5cc771c=""> this. $ parent </code> или изменяющиеся свойства. </strong></p><p data-v-d5cc771c=""> Идеальное приложение Vue - это поддержка, события - вверх. Соблюдение этого соглашения значительно упрощает понимание ваших компонентов.Однако есть крайние случаи, когда prop mutation или <code data-v-d5cc771c=""> this. $ Parent </code> может упростить два компонента, которые уже глубоко связаны.</p><p data-v-d5cc771c=""> Проблема в том, что существует также множество <em data-v-d5cc771c=""> простых </em> случаев, когда эти шаблоны могут быть удобны. Остерегайтесь: не поддавайтесь соблазну простоты торговли (способности понимать поток своего состояния) ради краткосрочного удобства (написания меньшего количества кода).</p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D0%BB%D0%BE%D1%85%D0%BE-21"></span> Плохо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> app.component ('TodoItem', {
  props: {
    сделать: {
      тип: Объект,
      требуется: true
    }
  },

  template: '<input v-model = "todo.текст "> '
})
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/> 8 <br data-v-d5cc771c=""/> 9 <br data-v-d5cc771c=""/> 10 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> app.component ('TodoItem', {
  props: {
    сделать: {
      тип: Объект,
      требуется: true
    }
  },

  методы: {
    removeTodo () {
      this. $ parent.todos = this. $ parent.todos.filter (todo => todo.id! == vm.todo.id)
    }
  },

  шаблон: `
    <span>
      {{todo.text}}
      <button @ click = "removeTodo">
        ×
      </button>
    </span>
  `
})
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/> 8 <br data-v-d5cc771c=""/> 9 <br data-v-d5cc771c=""/> 10 <br data-v-d5cc771c=""/> 11 <br data-v-d5cc771c=""/> 12 <br data-v-d5cc771c=""/> 13 <br data-v-d5cc771c=""/> 14 <br data-v-d5cc771c=""/> 15 <br data-v-d5cc771c=""/> 16 <br data-v-d5cc771c=""/> 17 <br data-v-d5cc771c=""/> 18 <br data-v-d5cc771c=""/> 19 <br data-v-d5cc771c=""/> 20 <br data-v-d5cc771c=""/> 21 <br data-v-d5cc771c=""/> 22 <br data-v-d5cc771c=""/> 942 942 942<h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%A5%D0%BE%D1%80%D0%BE%D1%88%D0%BE-23"></span> Хорошо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> ок.component ('TodoItem', {
  props: {
    сделать: {
      тип: Объект,
      требуется: true
    }
  },

  испускает: ['input'],

  шаблон: `
    <ввод
      : value = "todo.text"
      @input = "$ emit ('input', $ event.target.value)"
    >
  `
})
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/> 8 <br data-v-d5cc771c=""/> 9 <br data-v-d5cc771c=""/> 10 <br data-v-d5cc771c=""/> 11 <br data-v-d5cc771c=""/> 12 <br data-v-d5cc771c=""/> 13 <br data-v-d5cc771c=""/> 14 <br data-v-d5cc771c=""/> 15 <br data-v-d5cc771c=""/> 16 <br data-v-d5cc771c=""/> 17 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c=""> app.component ('TodoItem
  props: {
    сделать: {
      тип: Объект,
      требуется: true
    }
  },

  выдает: ['delete'],

  шаблон: `
    <span>
      {{ сделать.текст}}
      <button @click = "$ emit ('delete')">
        ×
      </button>
    </span>
  `
})
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/> 8 <br data-v-d5cc771c=""/> 9 <br data-v-d5cc771c=""/> 10 <br data-v-d5cc771c=""/> 11 <br data-v-d5cc771c=""/> 12 <br data-v-d5cc771c=""/> 13 <br data-v-d5cc771c=""/> 14 <br data-v-d5cc771c=""/> 15 <br data-v-d5cc771c=""/> 16 <br data-v-d5cc771c=""/> 17 <br data-v-d5cc771c=""/> 18 <br data-v-d5cc771c=""/> 19 <br data-v-d5cc771c=""/></p><h4 data-v-d5cc771c=""><span class="ez-toc-section" id="9_%D0%A3%D0%BF%D1%80%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81%D0%BE%D1%81%D1%82%D0%BE%D1%8F%D0%BD%D0%B8%D0%B5%D0%BC_%D0%B1%D0%B5%D0%B7_%D0%BF%D0%BE%D1%82%D0%BE%D0%BA%D0%B0_%D1%81_%D0%BE%D1%81%D1%82%D0%BE%D1%80%D0%BE%D0%B6%D0%BD%D0%BE%D1%81%D1%82%D1%8C%D1%8E"></span> 9 Управление состоянием без потока с осторожностью <span class="ez-toc-section-end"></span></h4></sup></h4><p data-v-d5cc771c=""> <strong data-v-d5cc771c=""> Vuex (открывает новое окно) следует предпочесть для глобального управления состоянием, а не <code data-v-d5cc771c=""> this. $ root </code> или глобальную шину событий.</strong></p><p data-v-d5cc771c=""> Управление состоянием на <code data-v-d5cc771c=""> this. $ Root </code> и / или использование глобальной шины событий может быть удобным для очень простых случаев, но не подходит для большинства приложений.</p><p data-v-d5cc771c=""> Vuex - это официальная подобная потоку реализация для Vue, предлагающая не только центральное место для управления состоянием, но и инструменты для организации, отслеживания и отладки изменений состояния. Он хорошо интегрируется в экосистему Vue (включая полную поддержку Vue DevTools).</p><h5 data-v-d5cc771c=""><span class="ez-toc-section" id="%D0%9F%D0%BB%D0%BE%D1%85%D0%BE-22"></span> Плохо <span class="ez-toc-section-end"></span></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c="">
импортировать {createApp} из "vue"
импортная рукавица из "рукавицы"
const app = createApp ({
  данные() {
    возвращение {
      задачи: [],
      эмиттер: рукавица ()
    }
  },

  созданный() {
    это.emitter.on ('remove-todo', this.removeTodo)
  },

  методы: {
    removeTodo (todo) {
      const todoIdToRemove = todo.id
      this.todos = this.todos.filter (todo => todo.id! == todoIdToRemove)
    }
  }
})
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/> 8 <br data-v-d5cc771c=""/> 9 <br data-v-d5cc771c=""/> 10 <br data-v-d5cc771c=""/> 11 <br data-v-d5cc771c=""/> 12 <br data-v-d5cc771c=""/> 13 <br data-v-d5cc771c=""/> 14 <br data-v-d5cc771c=""/> 15 <br data-v-d5cc771c=""/> 16 <br data-v-d5cc771c=""/> 17 <br data-v-d5cc771c=""/> 18 <br data-v-d5cc771c=""/> 19 <br data-v-d5cc771c=""/> 20 <br data-v-d5cc771c=""/> 21 <br data-v-d5cc771c=""/> 22<h5 data-v-d5cc771c=""></h5><pre data-v-d5cc771c=""> <code data-v-d5cc771c="">
экспорт по умолчанию {
  государство: {
    список: []
  },

  мутации: {
    REMOVE_TODO (состояние, todoId) {
      государство.list = state.list.filter (todo => todo.id! == todoId)
    }
  },

  действия: {
    removeTodo ({фиксация, состояние}, задача) {
      совершить ('REMOVE_TODO', todo.id)
    }
  }
}
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/> 8 <br data-v-d5cc771c=""/> 9 <br data-v-d5cc771c=""/> 10 <br data-v-d5cc771c=""/> 11 <br data-v-d5cc771c=""/> 12 <br data-v-d5cc771c=""/> 13 <br data-v-d5cc771c=""/> 14 <br data-v-d5cc771c=""/> 15 <br data-v-d5cc771c=""/> 16 <br data-v-d5cc771c=""/> 17 <br data-v-d5cc771c=""/> 18 <br data-v-d5cc771c=""/></p><pre data-v-d5cc771c=""> <code data-v-d5cc771c="">
<шаблон>
  <span>
    {{todo.text}}
    <button @ click = "removeTodo (todo)">
      Икс
    </button>
  </span>
</template>

<сценарий>
импортировать {mapActions} из 'vuex'

экспорт по умолчанию {
  props: {
    сделать: {
      тип: Объект,
      требуется: true
    }
  },

  методы: mapActions (['removeTodo'])
}
</script>
 </code> </pre><p> 1 <br data-v-d5cc771c=""/> 2 <br data-v-d5cc771c=""/> 3 <br data-v-d5cc771c=""/> 4 <br data-v-d5cc771c=""/> 5 <br data-v-d5cc771c=""/> 6 <br data-v-d5cc771c=""/> 7 <br data-v-d5cc771c=""/> 8 <br data-v-d5cc771c=""/> 9 <br data-v-d5cc771c=""/> 10 <br data-v-d5cc771c=""/> 11 <br data-v-d5cc771c=""/> 12 <br data-v-d5cc771c=""/> 13 <br data-v-d5cc771c=""/> 14 <br data-v-d5cc771c=""/> 15 <br data-v-d5cc771c=""/> 16 <br data-v-d5cc771c=""/> 17 <br data-v-d5cc771c=""/> 18 <br data-v-d5cc771c=""/> 19 <br data-v-d5cc771c=""/> 20 <br data-v-d5cc771c=""/> 21 <br data-v-d5cc771c=""/> 22909 <br data-v-d5cc771c=""/></p><h2><span class="ez-toc-section" id="%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D1%8B_%D1%81%D0%B8%D0%BD%D1%82%D0%B0%D0%BA%D1%81%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B3%D0%BE_%D0%B0%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%82%D0%BE%D1%80%D0%B0_%D0%BF%D0%BE%D1%88%D0%B0%D0%B3%D0%BE%D0%B2%D0%BE%D0%B5_%D1%80%D1%83%D0%BA%D0%BE%D0%B2%D0%BE%D0%B4%D1%81%D1%82%D0%B2%D0%BE"></span> Комбинаторы синтаксического анализатора: пошаговое руководство <span class="ez-toc-section-end"></span></h2><p> <strong> Или: напишите вам парсек для великого добра </strong></p><p> Большинство людей на пути к Haskell пойдут по тем же первым шагам.Во-первых, вам нужно познакомиться с самим языком, особенно если вы пришли к нему без каких-либо знаний функционального программирования: его необычный синтаксис, лень, отсутствие изменяемого состояния ... Оттуда вы можете перейти к объявлениям функций и типов, ознакомиться изучите функции Prelude (и их известные недостатки) и начните писать свои первые программы. Следующий большой шаг - это, конечно, монады, печально известное м-слово, и то, как мы используем их для структурирования наших программ.</p><p> Но потом, когда вы начали развивать интуицию для монад… путь становится неясным.Можно охватить гораздо больше, но все это не является столь фундаментальным. Есть примерно три категории тем, которые можно захотеть изучить:</p><ul><li> Продолжение самого языка: изучение языковых расширений, теории, лежащей в основе их, и расширенных функций, которые они предоставляют.</li><li> Узнать больше о различных способах структурирования программы (например, о преобразователях монад или системах эффектов).</li><li> Изучение некоторых из наиболее часто используемых библиотек и понимание того, что делает их такими повсеместными: QuickCheck, Lens… и Parsec.</li></ul><p> Сегодня я хочу изучить Parsec, и особенно <em>, как работает Parsec </em>. Синтаксический анализ применяется повсеместно, и большинство программ на Haskell будут использовать Parsec или один из его вариантов (мегапарсек или аттопарсек). Хотя эти библиотеки можно использовать, не беспокоясь о том, как они работают, я думаю, что интересно разработать мысленную модель для их внутреннего дизайна; а именно, комбинаторы монадического синтаксического анализатора <em> </em>, поскольку это простой и элегантный метод, который полезен за пределами варианта использования синтаксического анализа необработанного текста.В Hasura мы недавно использовали эту технику, чтобы переписать код, который генерирует схему GraphQL и проверяет входящий запрос GraphQL по ней.</p><p> Чтобы развить интуицию для этой техники, в ходе этой статьи мы сначала переопределим <strong> упрощенную версию Parsec </strong>, а затем воспользуемся ею, чтобы <strong> написать синтаксический анализатор для значений JSON </strong>. Наша цель здесь не будет заключаться в разработке полноценной библиотеки, как раз наоборот: мы реализуем строгий минимум, который нам нужен, чтобы сосредоточиться на основных идеях.</p><h3><span class="ez-toc-section" id="%D0%92%D1%8B%D0%B1%D0%BE%D1%80_%D0%BF%D1%80%D0%B5%D0%B4%D1%81%D1%82%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F_%D1%82%D0%B8%D0%BF%D0%B0_%D0%B4%D0%BB%D1%8F_%D0%BF%D0%B0%D1%80%D1%81%D0%B5%D1%80%D0%BE%D0%B2"></span> Выбор представления типа для парсеров <span class="ez-toc-section-end"></span></h3><p> С точки зрения высокого уровня синтаксический анализатор можно рассматривать как функцию перевода: он принимает в качестве входных данных некоторые слабо структурированные данные (большую часть времени: текст) и пытается преобразовать их в структурированные данные, следуя правилам формальная грамматика. Компилятор преобразует серию символов в абстрактное синтаксическое дерево, парсер JSON преобразует серию символов в эквивалентное представление Haskell значения JSON.Есть несколько алгоритмических подходов к этой проблеме; Комбинаторы синтаксического анализатора являются примером рекурсивного спуска <em> </em>: мы анализируем каждый термин нашей грамматики, рекурсивно вызывая синтаксические анализаторы для каждого подтермина.</p><p> Это означает, что под «синтаксическим анализатором» мы оба подразумеваем общее высокоуровневое преобразование и каждый из его отдельных шагов, поскольку каждый синтаксический анализатор рекурсивно выражается как комбинация других синтаксических анализаторов.</p><h4><span class="ez-toc-section" id="%D0%9C%D0%B8%D0%BD%D0%B8%D0%BC%D0%B0%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D0%B6%D0%B8%D0%B7%D0%BD%D0%B5%D1%81%D0%BF%D0%BE%D1%81%D0%BE%D0%B1%D0%BD%D0%B0%D1%8F_%D1%80%D0%B5%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F"></span> Минимальная жизнеспособная реализация <span class="ez-toc-section-end"></span></h4><p> Давайте шаг за шагом разберемся с типом парсера.Во-первых, мы установили, что синтаксический анализатор - это функция от некоторого заданного ввода до того, что мы пытаемся проанализировать. В этом проекте для простоты мы будем использовать <em> String </em> в качестве входных данных. Поэтому мы могли бы решить использовать следующее для представления наших синтаксических анализаторов:</p><pre> <code> Тип Parser a = String -> a
 </code> </pre><p> Но этого типа недостаточно для нашего случая использования. Прежде всего: синтаксический анализатор может выйти из строя, если ввод не соответствует тому, что диктует наша грамматика. Нам нужно будет определить соответствующий тип для представления ошибок, и синтаксический анализатор должен включить эту возможность на уровне типа.</p><pre> <code> тип Parser a = String -> Either ParseError a
 </code> </pre><p> Кроме того, синтаксический анализ - это <em> последовательная операция </em>: чтобы проанализировать объект JSON, нужно сначала проанализировать открывающую фигурную скобку, затем проанализировать записи, а затем проанализировать закрывающую фигурную скобку; рекурсивно, чтобы проанализировать запись, нужно сначала проанализировать ключ, затем двоеточие, а затем значение. Наш тип парсера будет использоваться для представления каждого из этих шагов, и мы не ожидаем, что каждый шаг полностью потребляет входную строку: поэтому каждый парсер должен также возвращать что-то, что указывает, где мы находимся во входном потоке, сколько из этого было потреблено, или то, что осталось обработать.</p><p> Поскольку мы используем <em> String </em> в качестве входного потока, каждому синтаксическому анализатору достаточно просто вернуть то, что осталось от входной строки. Тип <em> Parser </em>, который мы будем использовать, будет таким:</p><pre> <code> newtype Parser a = Parser {
  runParser :: String -> (Строка, Либо ParseError a)
}
 </code> </pre><h4><span class="ez-toc-section" id="%D0%9D%D0%B0%D0%BF%D0%B8%D1%81%D0%B0%D0%BD%D0%B8%D0%B5_%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%B0%D1%80%D0%BD%D1%8B%D1%85_%D0%BF%D0%B0%D1%80%D1%81%D0%B5%D1%80%D0%BE%D0%B2"></span> Написание элементарных парсеров <span class="ez-toc-section-end"></span></h4><p> Как это принято в Haskell, мы начинаем с рассмотрения «аксиоматических» базовых случаев, а затем обобщаем / экстраполируем оттуда.Учитывая, что наш поток - это <em> String </em>, а наши отдельные токены - это просто символы указанной строки, наши два базовых случая просто соответствуют двум конструкторам списка: во входном потоке остались токены или мы достигли конец. Мы называем эти две функции <em> любыми </em> и <em> eof </em> соответственно:</p><pre> <code> любой :: Parser Char
any = Parser $ \ input -> регистр ввода
  - осталось немного ввода: распаковываем и возвращаем первый символ
  (x: xs) -> (xs, вправо x)
  - ввода не осталось: анализатор не работает
  [] -> ("", Left $ ParseError
    «любой персонаж» - ожидается
    «конец ввода» - встретил
  )

eof :: Parser ()
eof = Parser $ \ input -> регистр ввода
  - ввода не осталось: синтаксический анализатор успешно завершает работу
  [] -> ("", Вправо ())
  - оставшиеся данные: анализатор не работает
  (c: _) -> (ввод, Left $ ParseError
    «конец ввода» - ожидается
    [c] - встречались
  )
 </code> </pre><p> Это <strong> только два базовых парсера </strong>, которые нам нужны! Они охватывают два базовых случая: у нас есть символ для синтаксического анализа или нет.Все остальное можно выразить в терминах этих двух и с помощью комбинаторов.</p><h4><span class="ez-toc-section" id="%D0%9F%D0%B0%D1%80%D1%81%D0%B5%D1%80%D1%8B_%D1%81%D0%B5%D0%BA%D0%B2%D0%B5%D0%BD%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F"></span> Парсеры секвенирования <span class="ez-toc-section-end"></span></h4><p> Как упоминалось ранее, синтаксический анализ <em> последовательный </em>. Нам часто нужно выразить что-то вроде: я хочу применить парсер <em> A </em>, затем парсер <em> B </em> и использовать их результаты. Давайте посмотрим, как мы могли бы реализовать синтаксический анализатор для записи объекта JSON, например: нам нужно проанализировать строку json, затем двоеточие, затем значение json (мы предполагаем, что эти отдельные синтаксические анализаторы уже существуют).Получающийся в результате код ... субоптимальный: повторяющийся, подверженный ошибкам и трудный для чтения:</p><pre> <code> jsonEntry :: Parser (String, JValue)
jsonEntry = Парсер $ \ input ->
  - разобрать строку json
  case runParser jsonString ввод
    (input2, Left err) -> (input2, Left err)
    (input2, правая клавиша) ->
      - при успехе: разобрать одно двоеточие
      case runParser (char ':') input2 из
        (input3, Left err) -> (input3, Left err)
        (input3, Right _) ->
          - в случае успеха: проанализировать значение json
          case runParser jsonValue input3 из
            (input4, Left err) -> (input4, Left err)
            (input4, Правое значение) ->
              - при успехе: вернуть результат
              (input4, Right (ключ, значение))
 </code> </pre><p> Это становится довольно громоздким как из-за того, что каждый шаг может завершиться неудачно, так и из-за того, что каждый шаг возвращает входные данные для следующего.Кроме того, это заставляет нас знать о внутренней структуре парсера, чтобы знать, как их объединить в цепочку. Чтобы упростить задачу, мы можем извлечь этот шаблон в отдельную функцию:</p><pre> <code> andThen :: Parser a -> (a -> Parser b) -> Parser b
parserA `andThen` f = Parser $ \ input ->
  case runParser parserA ввод
    (restOfInput, Right a) -> runParser (f a) restOfInput
    (restOfInput, Left e) -> (restOfInput, Left e)
 </code> </pre><p> Эта функция позволяет нам переписать наш синтаксический анализатор записи JSON таким образом, чтобы больше не требовалось явное самоанализирование каждого синтаксического анализатора на этом пути.</p><pre> <code> jsonEntry :: Parser (String, JValue)
jsonEntry =
  - разобрать строку json
  jsonString `andThen` \ ключ ->
    - разобрать одно двоеточие
    char ‘:’ `andThen` \ _ ->
      - проанализировать значение JSON
      jsonValue `andThen` \ значение ->
        - создать константный парсер, который не потребляет ввод
        constParser (ключ, значение)
 </code> </pre><h4><span class="ez-toc-section" id="%D0%A1%D0%B8%D0%BB%D0%BE%D0%B9_%D0%BC%D0%BE%D0%BD%D0%B0%D0%B4!"></span> Силой монад! <span class="ez-toc-section-end"></span></h4><p> Некоторым читателям этот паттерн <em> и затем </em> покажется знакомым; это потому, что <em> andThen </em> в точности совпадает с оператором связывания <em> Monad </em>:</p><pre> <code> (>> =) :: Parser a -> (a -> Parser b) -> Parser b
 </code> </pre><p> Сделав наш тип <em> Parser </em> экземпляром <em> Monad </em>, мы можем усилить мощь всех функций, которые идут с ним, и гораздо более удобный синтаксис <em> do notation </em> для наших синтаксических анализаторов.Наконец, нашу функцию <em> jsonEntry </em> можно кратко и прямо переписать:</p><pre> <code> jsonEntry :: Parser (String, JValue)
jsonEntry = do
  ключ <- jsonString
  _ <- char ‘:’
  значение <- jsonValue
  возврат (ключ, значение)
 </code> </pre><p> <em> В качестве примечания стоит упомянуть, что, хотя нотация </em> do <em> делает упорядочение явным, мы также будем использовать операторы во всем коде (иначе это не было бы «истинным Haskell»: P).В частности, следующие операторы </em> Functor <em> и </em> Applicative <em>: </em></p><pre> <code> (*>) :: Parser a -> Parser b -> Parser b
(<*) :: Parser a -> Parser b -> Parser a
(<$) :: a -> Парсер b -> Парсер a

- игнорировать ведущие пробелы
пробелы *> значение

- игнорировать конечные пробелы
значение <* пробелы

- подставить значение
Истина <$ строка «истина»
 </code> </pre><h4><span class="ez-toc-section" id="%D0%A0%D0%B5%D0%B7%D1%8E%D0%BC%D0%B5"></span> Резюме <span class="ez-toc-section-end"></span></h4><p> До сих пор мы определили два наших элементарных анализатора и увидели, что объединение в цепочку является монадической операцией.Все готово: удовлетворены наши основные потребности. Теперь мы можем приступить к описанию более интересных парсеров. Для начала давайте представим <em>, удовлетворяет </em>: небольшую оболочку вокруг <em> любого </em>, которая позволяет нам проверять, соответствует ли следующий символ во входных данных какому-либо произвольному требованию.</p><pre> <code> удовлетворить :: String -> (Char -> Bool) -> Parser Char
удовлетворить предикат описания = попробовать $ делать
  c <- любой
  если предикат c
    затем верните c
    else parseError описание [c]
 </code> </pre><p> Эта функция, хотя и проста, использует другие функции, с которыми мы еще не сталкивались, например <em> попробуйте </em>.Это наш первый комбинатор!</p><h3><span class="ez-toc-section" id="%D0%9E%D0%B1%D1%8A%D0%B5%D0%B4%D0%B8%D0%BD%D0%B5%D0%BD%D0%B8%D0%B5_%D0%BF%D0%B0%D1%80%D1%81%D0%B5%D1%80%D0%BE%D0%B2"></span> Объединение парсеров <span class="ez-toc-section-end"></span></h3><p> Формально комбинатор - это функция, которая не полагается ни на что, кроме своих аргументов, например <code> (.) </code> оператор композиции функции:</p><pre> <code> (f. G) x = f (g x)
 </code> </pre><p> Но неформально ... комбинатор - это <em>, что-то, что объединяет другие вещи </em>. И именно в том неформальном смысле мы используем его здесь! В нашем контексте комбинаторы синтаксического анализатора - это функции <em> синтаксических анализаторов </em>: функции, которые объединяют и преобразуют синтаксические анализаторы в другие синтаксические анализаторы для обработки таких вещей, как отслеживание с возвратом или повторение.</p><h4><span class="ez-toc-section" id="%D0%92%D1%8B%D0%B1%D0%BE%D1%80,_%D0%BE%D1%88%D0%B8%D0%B1%D0%BA%D0%B8_%D0%B8_%D0%B2%D0%BE%D0%B7%D0%B2%D1%80%D0%B0%D1%82"></span> Выбор, ошибки и возврат <span class="ez-toc-section-end"></span></h4><p> Мы знаем, что синтаксические анализаторы могут давать сбой: именно поэтому в их типе все-таки есть <em> Either </em>. Но не все ошибки фатальны: некоторые из них можно исправить. Представьте, например, что вы пытаетесь проанализировать значение JSON: это может быть объект, массив или строка ... Чтобы проанализировать такое значение, вы можете попытаться проанализировать открывающие фигурные скобки объекта: если это успешно, вы можете продолжить синтаксический анализ объекта; но если это немедленно не удается, вы можете вместо этого попытаться проанализировать открывающую скобку массива и так далее.Именно с ошибкой и возвратом мы можем реализовать нашу первую «расширенную» функцию: выбор.</p><p> Чтобы отличить настоящую ошибку, которая произошла дальше по строке, или что-то, что просто было неправильным выбором, мы проводим различие между синтаксическими анализаторами, которые не работают <em>, не потребляя никаких входных данных </em>, которые выходят из строя немедленно, и синтаксическими анализаторами, которые выходят из строя позже: мы предполагаем что если какой-либо ввод был потреблен, значит, мы оказались на правой «ветке». Но смотреть вперед только на один символ не всегда будет достаточно, чтобы решить, правильна ли ветвь, и в этом случае нам нужно иметь возможность вернуться назад, если ветка не удалась: нам нужен комбинатор с возвратом.Это то, что делает <em> try </em>: он преобразует синтаксический анализатор в анализатор с возвратом: тот, который не потребляет ввод в случае сбоя, который восстанавливает состояние до того, что было. Имеет смысл использовать его для <em>, чтобы удовлетворить </em>: если предикат не работает, мы не встретили ни одного символа, который можно было бы распаковать, и мы должны оставить входную строку неизменной.</p><pre> <code> try :: Parser a -> Parser a
попробуйте p = Parser $ \ state -> case runParser p состояние
  (_newState, левая ошибка) -> (состояние, левая ошибка)
  успех -> успех
 </code> </pre><p> В этом проекте мы называем комбинаторы точно так же, как Parsec.Оператор, который Parsec использует для представления выбора, такой же, как и оператор, определенный классом типов <em> Alternative </em>: <code> (<|>) </code>. Его семантика проста: если первый синтаксический анализатор вышел из строя, не потребляя никаких входных данных, попробуйте второй; в противном случае распространить ошибку:</p><pre> <code> (<|>) :: Parser a -> Parser a -> Parser a
p1 <|> p2 = Parser $ \ s -> case runParser p1 s из
  (s ', левая ошибка)
    | s '== s -> runParser p2 s
    | в противном случае -> (s ', левая ошибка)
  успех -> успех
 </code> </pre><p> С помощью этого оператора мы наконец можем реализовать гораздо более удобный комбинатор: <em> выбор </em>.Имея список парсеров, попробуйте их все, пока один из них не добьется успеха.</p><pre> <code> choice :: String -> [Parser a] -> Parser a
выбор описание = foldr (<|>) noMatch
  где noMatch = parseError описание "нет совпадения"
 </code> </pre><h4><span class="ez-toc-section" id="%D0%BF%D0%BE%D0%B2%D1%82%D0%BE%D1%80%D0%B5%D0%BD%D0%B8%D0%B5"></span> повторение <span class="ez-toc-section-end"></span></h4><p> Последняя группа комбинаторов, которая нам понадобится для нашего проекта, - это комбинаторы повторения. Они не требуют каких-либо внутренних знаний о нашем типе <em> Parser </em> и являются хорошим примером того, какую высокоуровневую абстракцию мы теперь можем написать.Как обычно, мы используем те же имена, что и Parsec: <em> many </em> эквивалентно звезде регулярного выражения и соответствует нулю или более вхождений данного синтаксического анализатора, а <em> many1 </em> эквивалентно плюсу: соответствует одному или нескольким вхождениям:</p><pre> <code> many, many1 :: Parser a -> Parser [a]
many p = many1 p <|> return []
many1 p = делать
  первый <- p
  отдых <- многие p
  возврат (первый: отдых)
 </code> </pre><p> Благодаря им мы также можем реализовать <code> sepBy </code> и <code> sepBy1 </code>, которые сопоставляют повторяющиеся вхождения данного парсера с заданным разделителем между ними:</p><pre> <code> sepBy, sepBy1 :: Parser a -> Parser s -> Parser [a]
sepBy p s = sepBy1 p s <|> return []
sepBy1 p s = делать
  первый <- p
  отдых <- многие (s >> p)
  возврат (первый: отдых)
 </code> </pre><h4><span class="ez-toc-section" id="%D0%A0%D0%B5%D0%B7%D1%8E%D0%BC%D0%B5-2"></span> Резюме <span class="ez-toc-section-end"></span></h4><p> Вот и все: эти семь комбинаторов - все, что нам нужно для реализации синтаксического анализатора JSON с нуля; на данный момент у нас уже есть достаточно хорошая минимальная реализация библиотеки комбинаторов синтаксического анализатора, подобной Parsec!</p><p> Конечно, полноценная библиотека реализует гораздо больше: больше примитивов для обработки символов, комбинаторы для необязательных синтаксических анализаторов, более конкретные комбинаторы повторения, поддержка улучшенных сообщений об ошибках… Но это выходит за рамки данного упражнения.</p><h3><span class="ez-toc-section" id="%D0%9F%D0%B0%D1%80%D1%81%D0%B5%D1%80%D1%8B_%D0%BD%D0%B0_%D0%BF%D1%80%D0%B0%D0%BA%D1%82%D0%B8%D0%BA%D0%B5_%D0%BF%D0%B0%D1%80%D1%81%D0%B8%D0%BD%D0%B3_JSON"></span> Парсеры на практике: парсинг JSON <span class="ez-toc-section-end"></span></h3><p> Чтобы собрать воедино все, что мы видели до сих пор, давайте шаг за шагом рассмотрим процесс построения грамматики парсера JSON. Мы будем делать это снизу вверх: начиная с синтаксических анализаторов для отдельных символов, затем перейдем к синтаксическим анализаторам, затем для скаляров… пока мы наконец не сможем выразить синтаксический анализатор для произвольного значения JSON. Цель здесь - продемонстрировать, как на каждом этапе мы можем использовать построенные нами более простые абстракции для создания чего-то более сложного.В этом разделе немного больше кода, но я надеюсь, что, если вы все до сих пор следили за всем, вам будет так же приятно читать, как и мне!</p><p> Мы будем использовать следующее представление для значений JSON, которое очень близко к тому, что определяет Aeson:</p><pre> <code> данные JValue
  = JObject (HashMap String JValue)
  | JArray [JValue]
  | JString String
  | JNumber Двухместный
  | JBool Bool
  | JNull
 </code> </pre><h4><span class="ez-toc-section" id="%D0%A0%D0%B0%D1%81%D0%BF%D0%BE%D0%B7%D0%BD%D0%B0%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%B7%D0%BD%D0%B0%D0%BA%D0%BE%D0%B2"></span> Распознавание знаков <span class="ez-toc-section-end"></span></h4><p> Использование функций <em> Data.Char </em>, давайте начнем определять нашу грамматику с определения типов символов, которые мы хотим распознать: это простое использование нашей функции <em> удовлетворения </em>:</p><pre> <code> char c = удовлетворить [c] (== c)
пробел = удовлетворить "пробел" isSpace
digit = удовлетворить "цифру" isDigit
 </code> </pre><h4><span class="ez-toc-section" id="%D0%A1%D0%B8%D0%BD%D1%82%D0%B0%D0%BA%D1%81%D0%B8%D1%81_%D1%8F%D0%B7%D1%8B%D0%BA%D0%B0"></span> Синтаксис языка <span class="ez-toc-section-end"></span></h4><p> Чтобы пойти дальше, мы можем определить удобные синтаксические функции, используя вышеупомянутые операторы <em> Applicative </em>:</p><pre> <code> строка = символ перемещения
пробелы = много места
символ s = строка s <* пробелы

между открыть закрыть значение = открыть *> значение <* закрыть
скобки = между (символ "[") (символ "]")
фигурные скобки = между (символ "{") (символ "}")
 </code> </pre>Реализация символа<p> <em> символа </em> здесь основана на определении Parsec лексемы <em> </em> (в их библиотеке определения языка), которая всегда пропускает завершающие пробелы; поэтому каждый синтаксический анализатор может быть безопасно написан с предположением, что нет начальных пробелов, которые он должен учитывать.Благодаря такому подходу в нашей грамматике JSON очень мало явных упоминаний пробелов.</p><h4><span class="ez-toc-section" id="%D0%A1%D0%BA%D0%B0%D0%BB%D1%8F%D1%80%D1%8B"></span> Скаляры <span class="ez-toc-section-end"></span></h4><p> Вот чем наша реализация будет отличаться от стандарта JSON. Для простоты наш парсер для чисел будет соответствовать только натуральным числам:</p><pre> <code> jsonNumber = читать <$> many1 цифру
 </code> </pre><p> Для логических значений мы просто сопоставляем два возможных случая:</p><pre> <code> jsonBool = choice "JSON boolean"
  [True <$ symbol "true"
  , False <$ symbol "false"
  ]
 </code> </pre><p> Что касается строк, мы сопоставляем последовательность символов между двумя двойными кавычками, но мы должны учитывать возможность того, что некоторые символы могут быть экранированы.Мы обрабатываем только небольшое подмножество экранированных символов, реализация остальной части спецификации оставлена ​​читателю в качестве упражнения. 🙂</p><pre> <code> jsonString =
  между (char '"') (char '"') (многие jsonChar) <* пробелы
  где
    jsonChar = choice "строковый символ JSON"
      [попробуйте $ '\ n' <$ string "\\ n"
      , попробуйте $ '\ t' <$ string "\\ t"
      , попробуйте $ '"' <$ string" \\\ ""
      , попробуйте $ '\\' <$ string "\\\\"
      , удовлетворить "не цитата" (/ = '"')
      ]
 </code> </pre><h4><span class="ez-toc-section" id="%D0%9C%D0%B0%D1%81%D1%81%D0%B8%D0%B2%D1%8B_%D0%B8_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B"></span> Массивы и объекты <span class="ez-toc-section-end"></span></h4> Значения<p> JSON по определению рекурсивны: массивы и объекты содержат другие значения JSON… Чтобы продолжить наш восходящий подход, мы предположим существование парсера <em> jsonValue </em> верхнего уровня, который будет определен последним.</p><p> Объект JSON - это группа отдельных записей, разделенных запятыми. Сначала мы анализируем их как список, используя комбинатор повторения, затем преобразуем упомянутый список ассоциаций в <em> HashMap </em>:</p><pre> <code> jsonObject = делать
  assocList <- фигурные скобки $ jsonEntry `sepBy` symbol", "
  вернуть $ fromList assocList
  где
    jsonEntry = do
      k <- jsonString
      символ ":"
      v <- jsonValue
      возврат (k, v)
 </code> </pre><p> Наконец, массив - это просто группа значений в скобках, разделенных запятыми:</p><pre> <code> jsonArray = скобки $ jsonValue `sepBy` symbol", "
 </code> </pre><h4><span class="ez-toc-section" id="%D0%A1%D0%BE%D0%B1%D0%B8%D1%80%D0%B0%D0%B5%D0%BC_%D0%B2%D1%81%D0%B5_%D0%B2%D0%BC%D0%B5%D1%81%D1%82%D0%B5"></span> Собираем все вместе <span class="ez-toc-section-end"></span></h4><p> Наконец, мы можем выразить парсер верхнего уровня для значения JSON:</p><pre> <code> jsonValue = выбор "значение JSON"
  [JObject <$> jsonObject
  , JArray <$> jsonArray
  , JString <$> jsonString
  , JNumber <$> jsonNumber
  , JBool <$> jsonBool
  , JNull <$ символ "ноль"
  ]
 </code> </pre><p> И… все!</p><h3><span class="ez-toc-section" id="%D0%9F%D0%BE%D0%B4%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5_%D0%B8%D1%82%D0%BE%D0%B3%D0%BE%D0%B2-2"></span> Подведение итогов <span class="ez-toc-section-end"></span></h3><p> Эта статья является результатом моего личного опыта, когда я пытался понять внутреннюю работу Parsec после многих лет его использования.Я попробовал свои силы в написании небольшого парсера JSON с нуля, на стороне, когда я узнал о том, что заставляет Parsec работать, чтобы лучше понять, применив его на практике. Когда я закончил, я был поражен тем, насколько <em> мал, </em> и лаконичен полученный код, а также тем, насколько простой была грамматика JSON. Я искренне надеюсь, что это пошаговое руководство окажется для вас полезным и даст вам представление о красоте комбинаторов синтаксического анализатора!</p><p> Весь код в этой статье можно найти в этой статье GitHub.</p><p> В качестве более сложного примера использования комбинаторов синтаксического анализатора, если вы хотите узнать больше о том, как мы использовали эту технику для повторной реализации нашей генерации схемы GraphQL, вы можете взглянуть на описание PR, в котором она была представлена.</p><p> Хасура, конечно, нанимает. Если обсуждения, подобные приведенным выше, кажутся вам интересными, просмотрите наши открытые роли и подайте заявку. Если вы хотите следить за тем, что строит команда, где мы говорим, а также за случайными гифками с детенышами животных.</div><footer class="entry-footer"><div id="author_box" class="row no-gutters"><div class="author_avatar col-2"> <img alt='' src="//xn--7-dtbea5camjj.xn--p1ai/wp-content/plugins/a3-lazy-load/assets/images/lazy_placeholder.gif" data-lazy-type="image" data-src='https://secure.gravatar.com/avatar/b142b184aa8663e4da31fb1a71be88cc?s=96&d=mm&r=g' srcset="" data-srcset='https://secure.gravatar.com/avatar/b142b184aa8663e4da31fb1a71be88cc?s=192&d=mm&r=g 2x' class='lazy lazy-hidden avatar avatar-96 photo' height='96' width='96' decoding='async'/><noscript><img alt='' src='https://secure.gravatar.com/avatar/b142b184aa8663e4da31fb1a71be88cc?s=96&d=mm&r=g' srcset='https://secure.gravatar.com/avatar/b142b184aa8663e4da31fb1a71be88cc?s=192&d=mm&r=g 2x' class='avatar avatar-96 photo' height='96' width='96' decoding='async'/></noscript></div><div class="author_info col-10"><h4 class="author_name title-font"> admin</h4><div class="author_bio"></div></div></div></footer></article><nav class="navigation post-navigation" aria-label="Записи"><h2 class="screen-reader-text">Навигация по записям</h2><div class="nav-links"><div class="nav-previous"><a href="https://xn--7-dtbea5camjj.xn--p1ai/raznoe/linii-na-ruke-chto-oboznachayut-linii-na-ruke-znachenie-opisanie.html" rel="prev"><span class="nav-title title-font">Линии на руке что обозначают: Линии на руке: значение, описание</span></a></div><div class="nav-next"><a href="https://xn--7-dtbea5camjj.xn--p1ai/raznoe/tehnika-risovaniya-maslom-dlya-nachinayushhih-stranicza-ne-najdena-ny-school-shkola-risovaniya-maslom.html" rel="next"><span class="nav-title title-font">Техника рисования маслом для начинающих: Страница не найдена — NY SCHOOL — Школа рисования маслом</span></a></div></div></nav><div id="comments" class="comments-area"><div id="respond" class="comment-respond"><h3 id="reply-title" class="comment-reply-title">Добавить комментарий <small><a rel="nofollow" id="cancel-comment-reply-link" href="/raznoe/razbor-slova-sdelat-po-sostavu-stranicza-ne-najdena.html#respond" style="display:none;">Отменить ответ</a></small></h3><form action="https://xn--7-dtbea5camjj.xn--p1ai/wp-comments-post.php" method="post" id="commentform" class="comment-form" novalidate><p class="comment-notes"><span id="email-notes">Ваш адрес email не будет опубликован.</span> <span class="required-field-message">Обязательные поля помечены <span class="required">*</span></span></p><p class="comment-form-comment"><label for="comment">Комментарий <span class="required">*</span></label><textarea id="comment" name="comment" cols="45" rows="8" maxlength="65525" required></textarea></p><p class="comment-form-author"><label for="author">Имя <span class="required">*</span></label> <input id="author" name="author" type="text" value="" size="30" maxlength="245" autocomplete="name" required /></p><p class="comment-form-email"><label for="email">Email <span class="required">*</span></label> <input id="email" name="email" type="email" value="" size="30" maxlength="100" aria-describedby="email-notes" autocomplete="email" required /></p><p class="comment-form-url"><label for="url">Сайт</label> <input id="url" name="url" type="url" value="" size="30" maxlength="200" autocomplete="url" /></p><p class="form-submit"><input name="submit" type="submit" id="submit" class="submit" value="Отправить комментарий" /> <input type='hidden' name='comment_post_ID' value='28334' id='comment_post_ID' /> <input type='hidden' name='comment_parent' id='comment_parent' value='0' /></p></form></div></div></main><aside id="secondary" class="widget-area order-2"><section id="categories-47" class="widget widget_categories"><h3 class="widget-title title-font"><span>Рубрики</span></h3><ul><li class="cat-item cat-item-10"><a href="https://xn--7-dtbea5camjj.xn--p1ai/category/vospityvat">Воспитывать</a></li><li class="cat-item cat-item-11"><a href="https://xn--7-dtbea5camjj.xn--p1ai/category/deti">Дети</a></li><li class="cat-item cat-item-13"><a href="https://xn--7-dtbea5camjj.xn--p1ai/category/podrostok">Подросток</a></li><li class="cat-item cat-item-9"><a href="https://xn--7-dtbea5camjj.xn--p1ai/category/pravilno">Правильно</a></li><li class="cat-item cat-item-8"><a href="https://xn--7-dtbea5camjj.xn--p1ai/category/raznoe">Разное</a></li><li class="cat-item cat-item-12"><a href="https://xn--7-dtbea5camjj.xn--p1ai/category/rekomendaczii">Рекомендации</a></li><li class="cat-item cat-item-1"><a href="https://xn--7-dtbea5camjj.xn--p1ai/category/sovety">Советы</a></li></ul></section></aside></div></div><div id="footer-sidebar" class="widget-area"><div class="container"><div class="row"></div></div></div><footer id="colophon" class="site-footer"><div class="site-info"> 2024 © Все права защищены.</div></footer></div><nav id="menu" class="panel" role="navigation"> <button class="go-to-bottom"></button> <button id="close-menu" class="menu-link"><i class="fa fa-times"></i></button><ul id="mobile-menu" class="menu"><li id="menu-item-26342" class="menu-item menu-item-type-taxonomy menu-item-object-category current-post-ancestor current-menu-parent current-post-parent mdl-list__item"><a href="https://xn--7-dtbea5camjj.xn--p1ai/category/raznoe"></i>Семейные советы</a></li><li id="menu-item-26343" class="menu-item menu-item-type-taxonomy menu-item-object-category mdl-list__item"><a href="https://xn--7-dtbea5camjj.xn--p1ai/category/pravilno"></i>Как правильно ?</a></li><li id="menu-item-26344" class="menu-item menu-item-type-taxonomy menu-item-object-category mdl-list__item"><a href="https://xn--7-dtbea5camjj.xn--p1ai/category/deti"></i>Дети</a></li><li id="menu-item-26345" class="menu-item menu-item-type-taxonomy menu-item-object-category mdl-list__item"><a href="https://xn--7-dtbea5camjj.xn--p1ai/category/vospityvat"></i>Воспитание</a></li></ul> <button class="go-to-top"></button></nav> <noscript><style>.lazyload{display:none}</style></noscript><script data-noptimize="1">window.lazySizesConfig=window.lazySizesConfig||{};window.lazySizesConfig.loadMode=1;</script><script async data-noptimize="1" src='https://xn--7-dtbea5camjj.xn--p1ai/wp-content/plugins/autoptimize/classes/external/js/lazysizes.min.js'></script> <!-- noptimize -->
<style>iframe,object{width:100%;height:480px}img{max-width:100%}</style><script>new Image().src="//counter.yadro.ru/hit?r"+escape(document.referrer)+((typeof(screen)=="undefined")?"":";s"+screen.width+"*"+screen.height+"*"+(screen.colorDepth?screen.colorDepth:screen.pixelDepth))+";u"+escape(document.URL)+";h"+escape(document.title.substring(0,150))+";"+Math.random();</script>
<!-- /noptimize --> <script defer src="https://xn--7-dtbea5camjj.xn--p1ai/wp-content/cache/autoptimize/js/autoptimize_c706670449099083c5851e477e8a29c4.js"></script></body></html><script src="/cdn-cgi/scripts/7d0fa10a/cloudflare-static/rocket-loader.min.js" data-cf-settings="3652a6ed13d93320c835bb33-|49" defer></script>