Как сделать на сайт калькулятор: uCalc is a universal builder of calculators and forms

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

Полис е-ОСАГО можно распечатать на принтере или предъявлять для проверки с экрана смартфона или планшета.

Остерегайтесь мошенников!

Будьте внимательны, покупайте электронное ОСАГО только на официальном сайте www.rgs.ru. Не прибегайте к помощи посредников – это незаконно! Вы рискуете приобрести недействующий или фальшивый полис ОСАГО. Проверить подлинность любого полиса ОСАГО можно на сайте РСА.

Урегулирование онлайн

Вы можете оперативно проверить статус вашего выплатного дела по полису ОСАГО или заявить о наступлении страхового случая.

Другие страховые продукты «Росгосстраха»:

Купить ОСАГО

Правила оформления

Как оформить ОСАГО онлайн?

1. Зарегистрироваться в личном кабинете.
2. Заполнить все данные в онлайн-калькуляторе.
3. Получить расчет стоимости.
4. Оплатить полис на сайте банковской картой.
5. Получить ОСАГО и сопроводительные документы на email.

Как продлить ОСАГО?

Если Вы уже клиент Росгосстраха, имеете доступ в личный кабинет и хотите продлить полис ОСАГО, вам нужно пройти 5 простых шагов:

1. Авторизоваться в личном кабинете.
2. Перейти в онлайн-калькулятор ОСАГО — все нужные данные будут уже заполнены.
3. Получить стоимость пролонгации.
4. Оплатить ОСАГО на сайте банковской картой.
5. Получить файл и сопроводительные документы на email.

Когда пора продлевать ОСАГО?

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

Продлить полис ОСАГО можно не ранее, чем за 2 месяца (60 дней) до истечения его срока действия.

Напоминаем, что за просроченный полис ОСАГО и за езду без полиса предусмотрен штраф.

Как проверить полис ОСАГО?

Подлинность полиса ОСАГО можно проверить на сайте РСА (Российского союза страховщиков).

Какие документы нужны для онлайн-покупки ОСАГО?

Для оформления страхового полиса вам потребуются следующие документы:

1. Паспорт страхователя и собственника автомобиля.
2. Свидетельство о регистрации транспортного средства (СТС) или паспорт транспортного средства (ПТС), если автомобиль не поставлен на учет..
3. Водительские удостоверения всех допущенных к управлению водителей, если условия договора подразумевают ограниченный перечень лиц, допущенных к управлению.
4. Действующая диагностическая карта на автомобиль, если автомобиль в соответствии с законодательством РФ проходил техосмотр.

Необходимы данные всех документов для точного расчета КБМ через автоматизированную информационную систему РСА.

Как оплатить электронное ОСАГО?

Безопасно оплатить полис можно банковской картой Visa, MasterCard, Maestro и национальной платежной картой «Мир».

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

У меня новое ТС/ Я новый водитель

Если у вас новое ТС или вы впервые в жизни оформляете ОСАГО, значит, ваших данных еще нет в системе РСА. Так как для получения полиса всем необходимо пройти эту проверку, то процедура для вас будет следующая:

1. Вам нужно заполнить все шаги калькулятора, на Шаге 4 подтвердить корректность заполненных данных и нажать кнопку «Далее».
2. После неуспешной проверки РСА вы увидите в том же окне форму для отправки копий ваших документов на проверку. Сделайте скан-копии или четкие фотографии всех указанных документов, добавьте их в форму и нажмите кнопку «Отправить документы на проверку». Сотрудник компании осуществит аутентификацию сведений содержащихся в сканированных копиях документов с данными указанными в калькуляторе.
3. В течение 20 минут вам на email придет письмо с результатами проверки и специальной ссылкой на расчет и оплату. Авторизуйтесь в личном кабинете, перейдите по ссылке и оплатите полис.
   Важно! Дата оплаты не должна совпадать с датой начала действия полиса, поэтому если полис нужен уже завтра, то оплатить его надо обязательно сегодня.

Я проездил год без аварий, какую скидку я получу?

При оформлении полиса ОСАГО (в любом виде) применяется коэффициент, соответствующий страховой истории, содержащейся в автоматизированной информационной системе РСА (Российского союза автостраховщиков).

Скидки за безаварийное вождение (если информация о них содержится в РСА) будут применены. За каждый год безаварийной езды начисляется скидка 5%. Максимальный размер скидки за 10 лет страхования может составить 50%.

Нужно ли заверять печатью электронный полис? Зачем нужна электронная подпись (файл sgn)?

Электронное ОСАГО — это оригинал вашего полиса.

1. Распечатайте файл электронного полиса на принтере и возите с собой в машине.
2. Распечатанный полис НЕ нужно заверять печатью или подписью в офисе!
3. Его не нужно обменивать на бумажный полис в офисе.

Вместо печати и подписи электронное ОСАГО заверяет электронная подпись, которая приходит вместе с полисом на ваш email. Файл с подписью (sgn) не нужно открывать или распечатывать, он просто хранится у вас. Дополнительная информация о подписи есть в сопроводительном письме, которое приходит с полисом.

Ответы на прочие вопросы.

Ответы на другие вопросы об ОСАГО (включая электронное ОСАГО и цену полиса) вы найдете в разделе Вопросы и ответы.

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

Что делать, если…

У меня проблемы с паролем

Если вам не приходит временный пароль либо он не подходит, проверьте папку «Спам» на своем email или повторите попытку позднее.

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

Ошибка «Неправильно выбран тип личного кабинета»

Убедитесь, что при входе в Личный кабинет вы выбираете правильный его тип: если вы представляете юридическое лицо, то над полем ввода email и пароля нужно отметить галочкой пункт «Отметьте, если вы являетесь юридическим лицом».

У меня нет с собой ПТС?

Номер и серия паспорта вашего ТС указан как в самом ПТС, так и в свидетельстве о регистрации ТС (СТС):

Уведомление «Не получено подтверждение от централизованных систем РСА»

Уведомление было получено, потому что введенные вами данные о водителях, автомобиле, собственнике не полностью совпадают с данными, которые содержатся в системе РСА.

1. Убедитесь, что вы правильно заполнили все данные заявления на страхование (проверьте опечатки, даты, адреса).
2. Если все необходимые условия оформления страховки выполняются, но вы все равно видите уведомление «Не получено подтверждение от централизованных систем РСА», воспользуйтесь специальной формой под расчетом и приложите скан-копии (четкие фотографии) документов, подтверждающие введенную вами информацию. Данные будут проверены сотрудником ПАО СК «Росгосстрах» в течение 20 минут, и вы сможете оформить договор на сайте в тот же день.

Что делать при техническом сбое?

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

Данные расчета сохраняются в браузере. Это можно отключить?

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

Желаете отключить функцию или просто очистить поля?

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

Не нахожу свою марку/модель ТС. Что делать?

Если вы не нашли в раскрывающемся списке свою марку (ни одно из представленных написаний не совпадает с наименованием марки ТС в ваших регистрационных документах), напишите в службу онлайн-поддержки (кнопка «Помощь» внизу экрана > «Задать свой вопрос» > выбрать тему обращения «Не нахожу марку своего ТС в списке» — мы добавим марку вашего ТС в список).

Если вы не нашли свою модель, внесите наименование модели в соответствии с данными регистрационных документов в поле «Отображать в полисе».

Что делать, если меня остановит ГИБДД?

Распечатайте заранее файл электронного полиса на принтере и возите с собой. Эту бумагу НЕ нужно заверять печатью или подписью — она уже заверена электронной подписью и является оригиналом полиса.

Ездить с распечатанным полисом законно! ГИБДД проверяет действительность вашего полиса по базе РСА. Вы сами тоже всегда можете проверить действительность своего полиса на сайте РСА.

Если вы беспокоитесь насчет проверок ГИБДД, то на этот случай вместе с полисом на электронную почту мы присылаем памятку со ссылками на законодательство в сфере электронного ОСАГО. Просто покажите ее сотруднику полиции.

Как создать приложение калькулятора HTML с нуля, используя JavaScript

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

К концу статьи вы должны получить калькулятор, который работает точно так же, как калькулятор iPhone (без функций +/- и процентов).

Предварительные требования

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

1. Операторы If / else
2. Для циклов
3. Функции JavaScript
4. Стрелочные функции
5. && и || Операторы
6. Как изменить текст с помощью свойства textContent
7. Как добавить прослушиватели событий с шаблоном делегирования событий

Перед тем, как начать

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

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

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

Создание калькулятора

Во-первых, мы хотим построить калькулятор.

Калькулятор состоит из двух частей: дисплея и клавиш.

  

  
 0 
  
… 
  

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

  .calculator__keys {
  дисплей: сетка;
  / * другой необходимый CSS * /
}  

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

  

   + 
   -  & times; 
   ÷  7 
   8 
   9 
   4 
   5 
   6 
   1 
   2 
   3 
   0 
  .
   AC 
   = 
  

Прослушивание нажатия клавиш

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

1. цифровая клавиша (0–9)
2. клавиша оператора (+, -, ×, ÷)
3. десятичная клавиша
4. клавиша равенства
5. клавиша очистки

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

  const Calculator = document.querySelector («. Calculator»)
const keys = Calculator.querySelector («. Calculator__keys»)

keys.addEventListener (‘click’, e => {
 if (e.target.matches (‘button’)) {
   // Сделай что-нибудь
 }
})  

Затем мы можем использовать атрибут data-action для определения типа нажатой клавиши.

  const key = e.цель
const action = key.dataset.action  

Если ключ не имеет атрибута data-action , это должен быть числовой ключ.

  если (! Действие) {
  console.log ('цифровой ключ!')
}  

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

  если (
  действие === 'добавить' ||
  действие === 'вычитание' ||
  действие === 'умножить' ||
  действие === 'разделить'
) {
  консоль.журнал ('ключ оператора!')
}  

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

Следуя тому же мыслительному процессу, если ключ data-action равен clear , мы знаем, что пользователь нажал кнопку очистки (та, которая говорит AC). Если ключ data-action равен вычислить , мы знаем, что пользователь щелкнул по клавише равенства.

  if (action === 'decimal') {
  console.log ('десятичный ключ!')
}

if (action === 'clear') {
  консоль.журнал ('ключ очистки!')
}

if (action === 'вычислить') {
  console.log ('равный ключ!')
}  

На этом этапе вы должны получить ответ console.log от каждой клавиши калькулятора.

Строим счастливый путь

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

Давайте назовем обычного человека Мэри.

Когда Мэри берет калькулятор, она может нажать любую из этих клавиш:

1. цифровая клавиша (0–9)
2. клавиша оператора (+, -, ×, ÷)
3. десятичная клавиша
4. равная клавиша
5. четкая клавиша

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

Когда пользователь нажимает цифровую клавишу

На этом этапе, если калькулятор показывает 0 (число по умолчанию), целевое число должно заменить ноль.

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

Здесь нам нужно знать две вещи:

1. Номер нажатой клавиши
2. Текущий отображаемый номер

Эти два значения можно получить через свойство textContent нажатой клавиши и .Calculator__display соответственно.

  const display = document.querySelector ('. Calculator__display')

keys.addEventListener ('клик', e => {
  if (e.target.matches ('button')) {
    константный ключ = e.target
    const действие = key.dataset.action
    const keyContent = key.textContent
    const displayNum = display.textContent
    // ...
  }
})  

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

  если (! Действие) {
  if (displayNum === '0') {
    display.textContent = keyContent
  }
}  

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

  если (! Действие) {
  if (displayNum === '0') {
    display.textContent = keyContent
  } еще {
    display.textContent = displayNum + keyContent
  }
}  

На этом этапе Мэри может щелкнуть любую из этих клавиш:

1. Десятичный ключ
2. Операторский ключ

Допустим, Мэри нажимает десятичный ключ.

Когда пользователь нажимает десятичную клавишу

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

Чтобы создать этот эффект, мы можем объединить . на отображаемый номер.

  if (action === 'decimal') {
  display.textContent = displayNum + '.'
}  

Далее, допустим, Мэри продолжает свои вычисления, нажимая клавишу оператора.

Когда пользователь нажимает клавишу оператора

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

Для этого мы можем добавить к клавише оператора класс is-pressressed .

  если (
  действие === 'добавить' ||
  действие === 'вычитание' ||
  действие === 'умножить' ||
  действие === 'разделить'
) {
  key.classList.add ('не работает')
}  

Как только Мэри нажмет клавишу оператора, она нажмет еще одну цифровую клавишу.

Когда пользователь нажимает цифровую клавишу после клавиши оператора

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

Чтобы освободить нажатое состояние, мы удаляем класс is-depressed со всех клавиш через цикл forEach :

  keys.addEventListener ('click', e => {
  if (e.target.matches ('button')) {
    константный ключ = e.target
    //...
    
    // Удаляем класс .is-depressed со всех клавиш
    Array.from (key.parentNode.children)
      .forEach (k => k.classList.remove ('находится в депрессии'))
  }
})  

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

Один из способов сделать это — использовать настраиваемый атрибут. Назовем этот настраиваемый атрибут data-previous-key-type .

  const Calculator = документ.querySelector ('. калькулятор')
// ...

keys.addEventListener ('клик', e => {
  if (e.target.matches ('button')) {
    // ...
    
    если (
      действие === 'добавить' ||
      действие === 'вычитание' ||
      действие === 'умножить' ||
      действие === 'разделить'
    ) {
      key.classList.add ('не работает')
      // Добавить настраиваемый атрибут
      Calculator.dataset.previousKeyType = 'оператор'
    }
  }
})  

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

  const previousKeyType = Calculator.dataset.previousKeyType

if (! action) {
  if (displayNum === '0' || previousKeyType === 'operator') {
    display.textContent = keyContent
  } еще {
    display.textContent = displayNum + keyContent
  }
}  

Далее, допустим, Мэри решает завершить вычисление нажатием клавиши равенства.

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

Когда Мэри нажимает клавишу равенства, калькулятор должен вычислить результат, который зависит от трех значений:

1. Первое число , введенное в калькулятор
2. Оператор
3. Второе число введенное в калькулятор

После вычисления результат должен заменить отображаемое значение.

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

  if (action === 'вычислить') {
  const secondValue = displayNum
  // ...
}  

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

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

  если (
  действие === 'добавить' ||
  действие === 'вычитание' ||
  действие === 'умножить' ||
  действие === 'разделить'
) {
  // ...
  Calculator.dataset.firstValue = displayNum
  Calculator.dataset.operator = действие
}  

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

  if (action === 'calculate') {
  const firstValue = Calculator.dataset.firstValue
  Оператор const = калькулятор.dataset.operator
  const secondValue = displayNum
  
  display.textContent = вычислить (firstValue, оператор, secondValue)
}  

Это означает, что нам нужно создать функцию Calculate . Он должен принимать три параметра: первое число, оператор и второе число.

  const вычислить = (n1, оператор, n2) => {
  // Выполняем расчет и возвращаем вычисленное значение
}  

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

  const вычислить = (n1, оператор, n2) => {
  пусть результат = ''
  
  if (operator === 'добавить') {
    результат = n1 + n2
  } else if (operator === 'subtract') {
    результат = n1 - n2
  } else if (operator === 'multiply') {
    результат = n1 * n2
  } еще если (оператор === 'делить') {
    результат = n1 / n2
  }
  
  вернуть результат
}  

Помните, что firstValue и secondValue на данный момент являются строками.Если вы сложите строки вместе, вы объедините их ( 1 + 1 = 11 ).

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

• parseInt преобразует строку в целое число .
• parseFloat преобразует строку в с плавающей точкой (это означает число с десятичными знаками).

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

  const вычислить = (n1, оператор, n2) => {
  пусть результат = ''
  
  if (operator === 'добавить') {
    результат = parseFloat (n1) + parseFloat (n2)
  } else if (operator === 'subtract') {
    результат = parseFloat (n1) - parseFloat (n2)
  } else if (operator === 'multiply') {
    результат = parseFloat (n1) * parseFloat (n2)
  } еще если (оператор === 'делить') {
    результат = parseFloat (n1) / parseFloat (n2)
  }
  
  вернуть результат
}  

Вот и все для счастливого пути!

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

Крайние случаи

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

Тим может нажимать эти клавиши в любом порядке:

1. Цифровая клавиша (0–9)
2. Операторская клавиша (+, -, ×, ÷)
3. Десятичная клавиша
4. Клавиша равенства
5. Очистить key

Что произойдет, если Тим нажмет десятичную клавишу

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

Здесь мы можем проверить, что отображаемое число содержит . с включает метод .

включает проверочных строк для данного совпадения. Если строка найдена, она возвращает true ; в противном случае возвращается false .

Примечание : включает с учетом регистра.

  // Пример включения работы.
const string = 'Гамбургеры очень вкусные!'
const hasExclaimation = строка.includes ('!')
консоль.log (hasExclaimation) // true  

Чтобы проверить, есть ли в строке точка, мы делаем следующее:

  // Ничего не делать, если в строке есть точка
if (! DisplayNum.includes ('.')) {
  display.textContent = displayNum + '.'
}  

Затем, если Тим нажимает десятичную клавишу после нажатия клавиши оператора, на дисплее должно отображаться 0. .

Здесь нам нужно знать, является ли предыдущий ключ оператором. Мы можем это сказать, проверив настраиваемый атрибут data-previous-key-type , который мы установили в предыдущем уроке.

data-previous-key-type еще не завершен. Чтобы правильно определить, является ли previousKeyType оператором, нам нужно обновить previousKeyType для каждой нажатой клавиши.

  если (! Действие) {
  // ...
  Calculator.dataset.previousKey = 'число'
}

if (action === 'decimal') {
  // ...
  Calculator.dataset.previousKey = 'десятичный'
}

if (action === 'clear') {
  // ...
  Calculator.dataset.previousKeyType = 'очистить'
}

if (action === 'вычислить') {
 //...
  Calculator.dataset.previousKeyType = 'вычислить'
}  

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

  if (action === 'decimal') {
  if (! DisplayNum.includes ('.')) {
    display.textContent = displayNum + '.'
  } else if (previousKeyType === 'operator') {
    display.textContent = '0'.
  }
  
Calculator.dataset.previousKeyType = 'десятичный'
}  

Что произойдет, если Тим нажмет клавишу оператора

Если Тим сначала нажмет клавишу оператора, клавиша оператора должна загореться.(Мы уже рассмотрели этот крайний случай, но как? Посмотрим, сможете ли вы определить, что мы сделали).

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

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

В-третьих, если Тим нажимает другую клавишу оператора после нажатия первой клавиши оператора, первая клавиша оператора должна быть отпущена.Затем следует нажать вторую клавишу оператора. (Мы рассмотрели и этот крайний случай — но как?).

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

Это означает, что нам нужно использовать функцию Calculate , когда существуют firstValue , operator и secondValue .

  если (
  действие === 'добавить' ||
  действие === 'вычитание' ||
  действие === 'умножить' ||
  действие === 'разделить'
) {
  const firstValue = калькулятор.dataset.firstValue
  Оператор const = Calculator.dataset.operator
  const secondValue = displayNum
  
// Примечание: достаточно проверить firstValue и оператор, потому что secondValue всегда существует
  if (firstValue && оператор) {
    display.textContent = вычислить (firstValue, оператор, secondValue)
  }
  
key.classList.add ('не работает')
  Calculator.dataset.previousKeyType = 'оператор'
  Calculator.dataset.firstValue = displayNum
  Calculator.dataset.operator = действие
}  

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

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

  если (
  firstValue &&
  оператор &&
  previousKeyType! == 'оператор'
) {
  display.textContent = вычислить (firstValue, оператор, secondValue)
}  

В-пятых, после того, как клавиша оператора вычисляет число, если Тим нажимает на число, за которым следует другой оператор, оператор должен продолжить вычисление, например: 8 - 1 = 7 , 7 - 2 = 5 , 5 - 3 = 2 .

Прямо сейчас наш калькулятор не может производить последовательные вычисления. Второе рассчитанное значение неверно. Вот что мы имеем: 99 - 1 = 98 , 98 - 1 = 0 .

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

Понимание нашей функции вычислений

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

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

В-третьих, допустим, пользователь нажимает второе значение - на этот раз это 1. На этом этапе отображаемое число обновляется до 1, но наши firstValue , operator и secondValue остаются неизменными.

В-четвертых, пользователь снова нажимает кнопку вычитания. Сразу после нажатия кнопки «Вычесть», прежде чем вычислить результат, мы устанавливаем значение secondValue в качестве отображаемого числа.

В-пятых, мы выполняем расчет с firstValue 99, operator subtract и secondValue 1. Результат - 98.

После вычисления результата мы устанавливаем отображение на результат. Затем мы устанавливаем operator на вычитание и firstValue на предыдущее отображаемое число.

Что ж, это ужасно неправильно! Если мы хотим продолжить вычисление, нам нужно обновить firstValue вычисленным значением.

  const firstValue = Calculator.dataset.firstValue
Оператор const = Calculator.dataset.operator
const secondValue = displayNum

если (
  firstValue &&
  оператор &&
  previousKeyType! == 'оператор'
) {
  const calcValue = вычислить (firstValue, оператор, secondValue)
  display.textContent = calcValue
  
// Обновить вычисленное значение как firstValue
  Calculator.dataset.firstValue = calcValue
} еще {
  // Если вычислений нет, установите displayNum в качестве firstValue
  калькулятор.dataset.firstValue = displayNum
}

key.classList.add ('не работает')
Calculator.dataset.previousKeyType = 'оператор'
Calculator.dataset.operator = action  

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

Что произойдет, если Тим нажмет клавишу равенства?

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

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

  if (action === 'вычислить') {
  const firstValue = Calculator.dataset.firstValue
  Оператор const = Calculator.dataset.operator
  const secondValue = displayNum
  
if (firstValue) {
    display.textContent = вычислить (firstValue, оператор, secondValue)
  }
  
Calculator.dataset.previousKeyType = 'вычислить'
}  

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

1. 2 + = -> 2 + 2 = 4
2. 2 - = -> 2 - 2 = 0
3. 2 × = -> 2 × 2 = 4
4. 2 ÷ = -> 2 ÷ 2 = 1

ср. уже приняли во внимание этот странный ввод.Вы понимаете почему? 🙂

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

1. Тим нажимает клавиши 5–1
2. Тим нажимает равное количество раз. Расчетное значение: 5 - 1 = 4
3. Тим совпадений. Расчетное значение: 4 - 1 = 3
4. Тим совпадений. Расчетное значение: 3 - 1 = 2
5. Тим совпадений. Расчетное значение: 2 - 1 = 1
6. Тим совпадений.Расчетное значение: 1 - 1 = 0

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

1. Тим нажимает клавиши 5–1
2. Тим нажимает одинаково. Расчетное значение: 4
3. Тим совпадений. Расчетное значение: 1

Исправление расчетов

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

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

В-третьих, пользователь нажимает второе значение. Допустим, это 1. На этом этапе отображаемое число обновляется до 1, но наши firstValue , operator и secondValue остаются неизменными.

В-четвертых, пользователь нажимает клавишу равенства. Сразу после нажатия кнопки равно, но перед вычислением мы устанавливаем secondValue как displayNum

В-пятых, калькулятор вычисляет результат 5 - 1 и дает 4 .Результат обновляется на дисплее. firstValue и оператор переносятся в следующий расчет, поскольку мы не обновляли их.

В-шестых, когда пользователь снова нажимает "равно", мы устанавливаем secondValue на displayNum перед вычислением.

Вы можете сказать, что здесь не так.

Вместо secondValue нам нужно установить firstValue на отображаемое число.

  if (action === 'вычислить') {
  пусть firstValue = калькулятор.dataset.firstValue
  Оператор const = Calculator.dataset.operator
  const secondValue = displayNum
  
if (firstValue) {
    if (previousKeyType === 'вычислить') {
      firstValue = displayNum
    }
    
display.textContent = вычислить (firstValue, оператор, secondValue)
  }
  
Calculator.dataset.previousKeyType = 'вычислить'
}  

Мы также хотим перенести предыдущее значение secondValue в новый расчет. Чтобы secondValue сохранялось до следующего вычисления, нам нужно сохранить его в другом настраиваемом атрибуте.Назовем этот настраиваемый атрибут modValue (обозначает значение модификатора).

  if (action === 'вычислить') {
  пусть firstValue = Calculator.dataset.firstValue
  Оператор const = Calculator.dataset.operator
  const secondValue = displayNum
  
if (firstValue) {
    if (previousKeyType === 'вычислить') {
      firstValue = displayNum
    }
    
display.textContent = вычислить (firstValue, оператор, secondValue)
  }
  
// Установить атрибут modValue
  Calculator.dataset.modValue = secondValue
  калькулятор.dataset.previousKeyType = 'вычислить'
}  

Если previousKeyType равно , вычислить , мы знаем, что можем использовать Calculator.dataset.modValue как secondValue . Как только мы это узнаем, мы сможем выполнить расчет.

  if (firstValue) {
  if (previousKeyType === 'вычислить') {
    firstValue = displayNum
    secondValue = Calculator.dataset.modValue
  }
  
display.textContent = вычислить (firstValue, оператор, secondValue)
}  

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

Вернуться к клавише равенства

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

Здесь, вместо того, чтобы просто проверять, является ли previousKeyType operator , нам также нужно проверить, является ли вычислить .

  если (! Действие) {
  если (
    DisplayNum === '0' ||
    previousKeyType === 'оператор' ||
    previousKeyType === 'вычислить'
  ) {
    отображать.textContent = keyContent
  } еще {
    display.textContent = displayNum + keyContent
  }
  Calculator.dataset.previousKeyType = 'число'
}

if (action === 'decimal') {
  if (! DisplayNum.includes ('.')) {
    display.textContent = displayNum + '.'
  } иначе, если (
    previousKeyType === 'оператор' ||
    previousKeyType === 'вычислить'
  ) {
    display.textContent = '0'.
  }
  
Calculator.dataset.previousKeyType = 'десятичный'
}  

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

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

  если (
  действие === 'добавить' ||
  действие === 'вычитание' ||
  действие === 'умножить' ||
  действие === 'разделить'
) {
  // ...
  
если (
    firstValue &&
    оператор &&
    previousKeyType! == 'оператор' &&
    previousKeyType! == 'вычислить'
  ) {
    const calcValue = вычислить (firstValue, оператор, secondValue)
    отображать.textContent = calcValue
    Calculator.dataset.firstValue = calcValue
  } еще {
    Calculator.dataset.firstValue = displayNum
  }
  
// ...
}  

Клавиша очистки имеет два использования:

1. All Clear (обозначается AC ) очищает все и сбрасывает калькулятор в исходное состояние.
2. Очистить запись (обозначается CE ) очищает текущую запись. Он сохраняет в памяти предыдущие числа.

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

Во-первых, если Тим нажимает клавишу (любую клавишу, кроме сброса), AC следует изменить на CE .

Мы делаем это, проверяя, является ли действие data-action clear . Если это не очистить , мы ищем кнопку очистки и меняем ее textContent .

  if (action! == 'clear') {
  const clearButton = Calculator.querySelector ('[data-action = clear]')
  clearButton.textContent = 'CE'
}  

Во-вторых, если Тим достигает CE , на дисплее должно отображаться 0.В то же время CE следует вернуть к AC , чтобы Тим мог сбросить калькулятор в исходное состояние. **

  if (action === 'clear') {
  display.textContent = 0
  key.textContent = 'AC'
  Calculator.dataset.previousKeyType = 'очистить'
}  

В-третьих, если Тим достигает AC , сбросьте калькулятор в исходное состояние.

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

  if (action === 'clear') {
  если (ключ.textContent === 'AC') {
    Calculator.dataset.firstValue = ''
    Calculator.dataset.modValue = ''
    Calculator.dataset.operator = ''
    Calculator.dataset.previousKeyType = ''
  } еще {
    key.textContent = 'AC'
  }
  
display.textContent = 0
  Calculator.dataset.previousKeyType = 'очистить'
}  

Вот и все - по крайней мере, для части крайних корпусов!

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

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

Рефакторинг кода

Рефакторинг часто начинается с наиболее очевидных улучшений. В этом случае давайте начнем с и вычислим .

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

1. Ранний возврат
2. Тернарные операторы
3. Чистые функции
4. ES6 Деструктуризация

Итак, давайте начнем!

Рефакторинг функции вычисления

Вот что у нас есть на данный момент.

  const вычислить = (n1, оператор, n2) => {
  пусть результат = ''
  if (operator === 'добавить') {
    результат = firstNum + parseFloat (n2)
  } else if (operator === 'subtract') {
    результат = parseFloat (n1) - parseFloat (n2)
  } else if (operator === 'multiply') {
    результат = parseFloat (n1) * parseFloat (n2)
  } еще если (оператор === 'делить') {
    результат = parseFloat (n1) / parseFloat (n2)
  }
  
  вернуть результат
}  

Вы узнали, что нам следует максимально сократить количество повторных назначений.Здесь мы можем удалить присвоения, если мы вернем результат вычисления в пределах операторов if и else if :

  const calculate = (n1, operator, n2) => {
  if (operator === 'добавить') {
    вернуть firstNum + parseFloat (n2)
  } else if (operator === 'subtract') {
    вернуть parseFloat (n1) - parseFloat (n2)
  } else if (operator === 'multiply') {
    вернуть parseFloat (n1) * parseFloat (n2)
  } еще если (оператор === 'делить') {
    вернуть parseFloat (n1) / parseFloat (n2)
  }
}  

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

  const вычислить = (n1, оператор, n2) => {
  if (operator === 'добавить') {
    вернуть firstNum + parseFloat (n2)
  }
  
  if (operator === 'subtract') {
    вернуть parseFloat (n1) - parseFloat (n2)
  }
  
  if (operator === 'умножить') {
    вернуть parseFloat (n1) * parseFloat (n2)
  }
  
  if (оператор === 'делить') {
    вернуть parseFloat (n1) / parseFloat (n2)
  }
}  

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

  const calculate = (n1, operator, n2) => {
  if (operator === 'add') вернуть parseFloat (n1) + parseFloat (n2)
  if (operator === 'subtract') вернуть parseFloat (n1) - parseFloat (n2)
  если (оператор === 'умножить') вернуть parseFloat (n1) * parseFloat (n2)
  если (оператор === 'делить') вернуть parseFloat (n1) / parseFloat (n2)
}  

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

  const calculate = (n1, operator, n2) => {
  const firstNum = parseFloat (n1)
  const secondNum = parseFloat (n2)
  если (оператор === 'добавить') вернуть firstNum + secondNum
  if (operator === 'subtract') вернуть firstNum - secondNum
  if (operator === 'multiply') вернуть firstNum * secondNum
  если (оператор === 'делить') вернуть firstNum / secondNum
}  

Мы закончили с , теперь вычислим . Вам не кажется, что это легче читать по сравнению с тем, что было раньше?

Реорганизация прослушивателя событий

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

  keys.addEventListener ('click', e => {
  if (e.target.matches ('button')) {
  
    если (! действие) {/ * ... * /}
    
    если (действие === 'добавить' ||
      действие === 'вычитание' ||
      действие === 'умножить' ||
      action === 'разделять') {
      / * ... * /
    }
    
    if (action === 'clear') {/ * ... * /}
    if (действие! == 'очистить') {/ * ... * /}
    if (action === 'вычислить') {/ * ... * /}
  }
})  

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

  // Не делайте этого!
const handleNumberKeys = (/ *... * /) => {/ * ... * /}
const handleOperatorKeys = (/ * ... * /) => {/ * ... * /}
const handleDecimalKey = (/ * ... * /) => {/ * ... * /}
const handleClearKey = (/ * ... * /) => {/ * ... * /}
const handleCalculateKey = (/ * ... * /) => {/ * ... * /}  

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

Лучше всего разделить код на чистые и нечистые функции. Если вы это сделаете, вы получите следующий код:

  ключей.addEventListener ('клик', e => {
  // Чистая функция
  const resultString = createResultString (/ * ... * /)
  
  // нечистоты
  display.textContent = resultString
  updateCalculatorState (/ * ... * /)
})  

Здесь createResultString - это чистая функция, которая возвращает то, что необходимо отобразить на калькуляторе. updateCalculatorState - это нечистая функция, которая изменяет внешний вид калькулятора и настраиваемые атрибуты.

Создание createResultString

Как упоминалось ранее, createResultString должен возвращать значение, которое необходимо отобразить на калькуляторе.
Эти значения можно получить с помощью частей кода, в которых указано display.textContent = 'some value .

  display.textContent = 'some value'  

Вместо display.textContent = 'some value' мы хотим вернуть каждое значение, чтобы мы могли использовать его позже.

  // замените вышеприведенное на это
return 'some value'  

Давайте рассмотрим это вместе, шаг за шагом, начиная с цифровых клавиш.

Создание строки результата для цифровых клавиш

Вот код, который у нас есть для цифровых клавиш:

  if (! Action) {
  если (
    DisplayNum === '0' ||
    previousKeyType === 'оператор' ||
    previousKeyType === 'вычислить'
  ) {
    отображать.textContent = keyContent
  } еще {
    display.textContent = displayNum + keyContent
  }
  Calculator.dataset.previousKeyType = 'число'
}  

Первый шаг - скопировать части, которые говорят display.textContent = 'some value' , в createResultString . Когда вы это сделаете, убедитесь, что вы изменили display.textContent = на return .

  const createResultString = () => {
  if (! action) {
    если (
      DisplayNum === '0' ||
      previousKeyType === 'оператор' ||
      previousKeyType === 'вычислить'
    ) {
      вернуть keyContent
    } еще {
      return отображаетсяNum + keyContent
    }
  }
}  

Затем мы можем преобразовать оператор if / else в тернарный оператор:

  const createResultString = () => {
  if (действие!) {
    return DisplayNum === '0' ||
      previousKeyType === 'оператор' ||
      previousKeyType === 'вычислить'
      ? keyContent
      : displayNum + keyContent
  }
}  

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

  const createResultString = () => {
  // Необходимые переменные:
  // 1. keyContent
  // 2. displayNum
  // 3. previousKeyType
  // 4. действие
  
  if (действие!) {
    return DisplayNum === '0' ||
      previousKeyType === 'оператор' ||
      previousKeyType === 'вычислить'
      ? keyContent
      : displayNum + keyContent
  }
}  

Создание строки результата для десятичного ключа

Вот код, который у нас есть для десятичного ключа:

  if (action === 'decimal') {
  если (! отображаетсяНум.включает('.')) {
    display.textContent = displayNum + '.'
  } иначе, если (
    previousKeyType === 'оператор' ||
    previousKeyType === 'вычислить'
  ) {
    display.textContent = '0'.
  }
  
  Calculator.dataset.previousKeyType = 'десятичный'
}  

Как и раньше, мы хотим переместить все, что изменяет display.textContent , в createResultString .

  const createResultString = () => {
  // ...
  
  if (action === 'decimal') {
    если (! отображаетсяНум.включает('.')) {
      return = displayNum + '.'
    } else if (previousKeyType === 'operator' || previousKeyType === 'вычислить') {
      return = '0'.
    }
  }
}  

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

  const createResultString = () => {
  // ...
  
  if (action === 'decimal') {
    if (! DisplayNum.includes ('.')) верните DisplayNum + '.'
    if (previousKeyType === 'operator' || previousKeyType === 'calculate') return '0.'
  }
}  

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

  const createResultString = () => {
  // ...
  
  if (action === 'decimal') {
    если (! отображаетсяНум.включает ('.')) return displayNum + '.'
    if (previousKeyType === 'operator' || previousKeyType === 'calculate') вернет '0.'
    возврат отображаетсяNum
  }
}  

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

  const createResultString = () => {
  // Необходимые переменные:
  // 1. keyContent
  // 2. displayNum
  // 3. previousKeyType
  // 4. действие
}  

Создание строки результата для клавиш оператора

Вот код, который мы написали для клавиш оператора.

  если (
  действие === 'добавить' ||
  действие === 'вычитание' ||
  действие === 'умножить' ||
  действие === 'разделить'
) {
  const firstValue = Calculator.dataset.firstValue
  Оператор const = Calculator.dataset.operator
  const secondValue = displayNum
  
  если (
    firstValue &&
    оператор &&
    previousKeyType! == 'оператор' &&
    previousKeyType! == 'вычислить'
  ) {
    const calcValue = вычислить (firstValue, оператор, secondValue)
    display.textContent = calcValue
    калькулятор.dataset.firstValue = calcValue
  } еще {
    Calculator.dataset.firstValue = displayNum
  }
  
  key.classList.add ('не работает')
  Calculator.dataset.previousKeyType = 'оператор'
  Calculator.dataset.operator = действие
}  

Вы уже знаете, что такое упражнение: мы хотим переместить все, что изменяет display.textContent , в createResultString . Вот что нужно переместить:

  const createResultString = () => {
  // ...
  если (
    действие === 'добавить' ||
    действие === 'вычитание' ||
    действие === 'умножить' ||
    действие === 'разделить'
  ) {
    const firstValue = калькулятор.dataset.firstValue
    Оператор const = Calculator.dataset.operator
    const secondValue = displayNum
    
    если (
      firstValue &&
      оператор &&
      previousKeyType! == 'оператор' &&
      previousKeyType! == 'вычислить'
    ) {
      вернуть вычислить (firstValue, оператор, secondValue)
    }
  }
}  

Помните, createResultString должен вернуть значение, которое будет отображаться на калькуляторе. Если условие if не соответствует, мы все равно хотим вернуть отображаемое число.

  const createResultString = () => {
  // ...
  если (
    действие === 'добавить' ||
    действие === 'вычитание' ||
    действие === 'умножить' ||
    действие === 'разделить'
  ) {
    const firstValue = Calculator.dataset.firstValue
    Оператор const = Calculator.dataset.operator
    const secondValue = displayNum
    
    если (
      firstValue &&
      оператор &&
      previousKeyType! == 'оператор' &&
      previousKeyType! == 'вычислить'
    ) {
      вернуть вычислить (firstValue, оператор, secondValue)
    } еще {
      возврат отображаетсяNum
    }
  }
}  

Затем мы можем преобразовать оператор if / else в тернарный оператор:

  const createResultString = () => {
  //...
  если (
    действие === 'добавить' ||
    действие === 'вычитание' ||
    действие === 'умножить' ||
    действие === 'разделить'
  ) {
    const firstValue = Calculator.dataset.firstValue
    Оператор const = Calculator.dataset.operator
    const secondValue = displayNum
    
    вернуть firstValue &&
      оператор &&
      previousKeyType! == 'оператор' &&
      previousKeyType! == 'вычислить'
      ? вычислить (первое значение, оператор, второе значение)
      : DisplayNum
  }
}  

Если вы присмотритесь, то поймете, что нет необходимости хранить переменную secondValue .Мы можем использовать DisplayNum непосредственно в функции calculate .

  const createResultString = () => {
  // ...
  если (
    действие === 'добавить' ||
    действие === 'вычитание' ||
    действие === 'умножить' ||
    действие === 'разделить'
  ) {
    const firstValue = Calculator.dataset.firstValue
    Оператор const = Calculator.dataset.operator
    
    вернуть firstValue &&
      оператор &&
      previousKeyType! == 'оператор' &&
      previousKeyType! == 'вычислить'
      ? вычислить (firstValue, оператор, displayNum)
      : DisplayNum
  }
}  

Наконец, обратите внимание на необходимые переменные и свойства.На этот раз нам понадобится Calculator.dataset.firstValue и Calculator.dataset.operator .

  const createResultString = () => {
  // Необходимые переменные и свойства:
  // 1. keyContent
  // 2. displayNum
  // 3. previousKeyType
  // 4. действие
  // 5. Calculator.dataset.firstValue
  // 6. Calculator.dataset.operator
}  

Создание строки результата для ключа очистки

Мы написали следующий код для обработки ключа очистки .

  if (action === 'clear') {
  if (key.textContent === 'AC') {
    Calculator.dataset.firstValue = ''
    Calculator.dataset.modValue = ''
    Calculator.dataset.operator = ''
    Calculator.dataset.previousKeyType = ''
  } еще {
    key.textContent = 'AC'
  }
  
  display.textContent = 0
  Calculator.dataset.previousKeyType = 'очистить'
}  

Как и выше, нужно переместить все, что изменяет display.textContent , в createResultString .

  const createResultString = () => {
  //...
  если (действие === 'очистить') вернуть 0
}  

Создание строки результата для ключа равенства

Вот код, который мы написали для ключа равенства:

  if (action === 'calculate') {
  пусть firstValue = Calculator.dataset.firstValue
  Оператор const = Calculator.dataset.operator
  пусть secondValue = отображаетсяNum
  
  if (firstValue) {
    if (previousKeyType === 'вычислить') {
      firstValue = displayNum
      secondValue = Calculator.dataset.modValue
    }
    
    отображать.textContent = вычислить (firstValue, оператор, secondValue)
  }
  
  Calculator.dataset.modValue = secondValue
  Calculator.dataset.previousKeyType = 'вычислить'
}  

Как и выше, мы хотим скопировать все, что изменяет display.textContent , в createResultString . Вот что нужно скопировать:

  if (action === 'calculate') {
  пусть firstValue = Calculator.dataset.firstValue
  Оператор const = Calculator.dataset.operator
  пусть secondValue = отображаетсяNum
  
  if (firstValue) {
    if (previousKeyType === 'вычислить') {
      firstValue = displayNum
      secondValue = калькулятор.dataset.modValue
    }
    display.textContent = вычислить (firstValue, оператор, secondValue)
  }
}  

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

  const createResultString = () => {
  // ...
  
  if (action === 'вычислить') {
    пусть firstValue = Calculator.dataset.firstValue
    Оператор const = Calculator.dataset.operator
    пусть secondValue = отображаетсяNum
    
    if (firstValue) {
      if (previousKeyType === 'вычислить') {
        firstValue = displayNum
        secondValue = калькулятор.dataset.modValue
      }
      вернуть вычислить (firstValue, оператор, secondValue)
    } еще {
      возврат отображаетсяNum
    }
  }
}  

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

  const createResultString = () => {
  // ...
  
  if (action === 'вычислить') {
    const firstValue = Calculator.dataset.firstValue
    Оператор const = Calculator.dataset.operator
    const modValue = калькулятор.dataset.modValue
    
    if (firstValue) {
      вернуть предыдущийKeyType === 'вычислить'
        ? вычислить (отображается число, оператор, modValue)
        : вычислить (firstValue, оператор, displayNum)
    } еще {
      возврат отображаетсяNum
    }
  }
}  

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

  const createResultString = () => {
  // ...
  
  if (action === 'вычислить') {
    const firstValue = калькулятор.dataset.firstValue
    Оператор const = Calculator.dataset.operator
    const modValue = Calculator.dataset.modValue
    
    вернуть firstValue
      ? previousKeyType === 'вычислить'
        ? вычислить (отображается число, оператор, modValue)
        : вычислить (firstValue, оператор, displayNum)
      : DisplayNum
  }
}  

На этом этапе мы хотим снова обратить внимание на требуемые свойства и переменные:

  const createResultString = () => {
  // Необходимые переменные и свойства:
  // 1.keyContent
  // 2. displayNum
  // 3. previousKeyType
  // 4. действие
  // 5. Calculator.dataset.firstValue
  // 6. Calculator.dataset.operator
  // 7. Calculator.dataset.modValue
}  

Передача необходимых переменных

Нам нужны семь свойств / переменных в createResultString :

1. keyContent
2. displayNum
3. previousKeyType
4. 45 action13
5. 45 modValue
6. operator

Мы можем получить keyContent и action из key .Мы также можем получить firstValue , modValue , operator и previousKeyType из Calculator.dataset .

Это означает, что для функции createResultString требуются три переменные: ключ , displayNum и Calculator.dataset . Поскольку Calculator.dataset представляет состояние калькулятора, давайте вместо этого будем использовать переменную с именем state .

  const createResultString = (ключ, отображаемое число, состояние) => {
  const keyContent = ключ.textContent
  const действие = key.dataset.action
  const firstValue = state.firstValue
  const modValue = state.modValue
  const оператор = состояние. оператор
  const previousKeyType = state.previousKeyType
  // ... Рефакторинг по мере необходимости
}

// Использование createResultString
keys.addEventListener ('клик', e => {
  если (e.target.matches ('button')) return
  const displayNum = display.textContent
  const resultString = createResultString (e.target, displayNum, Calculator.dataset)
  
  // ...
})  

Не стесняйтесь деструктурировать переменные, если хотите:

  const createResultString = (key, displayNum, state) => {
  const keyContent = ключ.textContent
  const {действие} = key.dataset
  const {
    firstValue,
    modValue,
    оператор
    previousKeyType
  } = состояние
  
  // ...
}  

Согласованность внутри операторов if

В createResultString мы использовали следующие условия для проверки типа нажатых клавиш:

  // Если ключ - это число
если (! действие) {/ * ... * /}

// Если ключ десятичный
if (действие === 'десятичное') {/ * ... * /}

// Если ключ - оператор
если (
  действие === 'добавить' ||
  действие === 'вычитание' ||
  действие === 'умножить' ||
  действие === 'разделить'
) {/ *... * /}

// Если ключ очищен
if (action === 'clear') {/ * ... * /}

// Если ключ вычислен
if (action === 'calculate') {/ * ... * /}  

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

  if (keyType === 'number') {/ * ... * /}
if (keyType === 'десятичный') {/ * ... * /}
if (keyType === 'оператор') {/ * ... * /}
if (keyType === 'clear') {/ * ... * /}
if (keyType === 'calculate') {/ * ... * /}  

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

  const getKeyType = (ключ) => {
  const {действие} = key.dataset
  если (! действие) вернет "число"
  если (
    действие === 'добавить' ||
    действие === 'вычитание' ||
    действие === 'умножить' ||
    действие === 'разделить'
  ) return 'оператор'
  // Для всего остального вернуть действие
  обратное действие
}  

Вот как вы будете использовать эту функцию:

  const createResultString = (key, displayNum, state) => {
  const keyType = getKeyType (ключ)
  
  if (keyType === 'число') {/ *... * /}
  if (keyType === 'десятичный') {/ * ... * /}
  if (keyType === 'оператор') {/ * ... * /}
  if (keyType === 'clear') {/ * ... * /}
  if (keyType === 'вычислить') {/ * ... * /}
}  

Мы закончили с createResultString . Перейдем к updateCalculatorState .

Создание updateCalculatorState

updateCalculatorState — это функция, которая изменяет внешний вид калькулятора и настраиваемые атрибуты.

Как и в случае с createResultString , нам нужно проверить тип нажатой клавиши.Здесь мы можем повторно использовать getKeyType .

  const updateCalculatorState = (ключ) => {
  const keyType = getKeyType (ключ)
  
  if (keyType === 'число') {/ * ... * /}
  if (keyType === 'десятичный') {/ * ... * /}
  if (keyType === 'оператор') {/ * ... * /}
  if (keyType === 'clear') {/ * ... * /}
  if (keyType === 'вычислить') {/ * ... * /}
}  

Если вы посмотрите на оставшийся код, вы можете заметить, что мы изменили data-previous-key-type для каждого типа ключа.Вот как выглядит код:

  const updateCalculatorState = (ключ, калькулятор) => {
  const keyType = getKeyType (ключ)
  
  if (! action) {
    // ...
    Calculator.dataset.previousKeyType = 'число'
  }
  
  if (action === 'decimal') {
    // ...
    Calculator.dataset.previousKeyType = 'десятичный'
  }
  
  если (
    действие === 'добавить' ||
    действие === 'вычитание' ||
    действие === 'умножить' ||
    действие === 'разделить'
  ) {
    // ...
    Calculator.dataset.previousKeyType = 'оператор'
  }
  
  if (action === 'clear') {
    //...
    Calculator.dataset.previousKeyType = 'очистить'
  }
  
  if (action === 'вычислить') {
    Calculator.dataset.previousKeyType = 'вычислить'
  }
}  

Это избыточно, потому что мы уже знаем тип ключа с getKeyType . Мы можем выполнить рефакторинг приведенного выше кода:

  const updateCalculatorState = (key, Calculator) => {
  const keyType = getKeyType (ключ)
  Calculator.dataset.previousKeyType = keyType
    
  if (keyType === 'число') {/ * ... * /}
  if (keyType === 'decimal') {/ *... * /}
  if (keyType === 'оператор') {/ * ... * /}
  if (keyType === 'clear') {/ * ... * /}
  if (keyType === 'вычислить') {/ * ... * /}
}  

Создание

  const updateCalculatorState = (ключ, калькулятор) => {
  const keyType = getKeyType (ключ)
  Calculator.dataset.previousKeyType = keyType
  
  Множество.from (key.parentNode.children) .forEach (k => k.classList.remove ('находится в депрессии'))
}  

  if (keyType === 'operator') {
  если (firstValue &&
      оператор &&
      previousKeyType! == 'оператор' &&
      previousKeyType! == 'вычислить'
  ) {
    Calculator.dataset.firstValue = CalculatorValue
  } еще {
    калькулятор.dataset.firstValue = displayNum
  }
  
  key.classList.add ('не работает')
  Calculator.dataset.operator = key.dataset.action
}  

  if (keyType === 'operator') {
  key.classList.add ('не работает')
  Calculator.dataset.operator = key.dataset.action
  Calculator.dataset.firstValue = firstValue &&
    оператор &&
    previousKeyType! == 'оператор' &&
    previousKeyType! == 'вычислить'
    ? CalculatedValue
    : DisplayNum
}  

  const updateCalculatorState = (ключ, калькулятор) => {
  // Необходимые переменные и свойства
  // 1. ключ
  // 2. калькулятор
  // 3. CalculatedValue
  // 4. displayNum
}  

  if (action === 'clear') {
  if (key.textContent === 'AC') {
    калькулятор.dataset.firstValue = ''
    Calculator.dataset.modValue = ''
    Calculator.dataset.operator = ''
    Calculator.dataset.previousKeyType = ''
  } еще {
    key.textContent = 'AC'
  }
}

if (action! == 'clear') {
  const clearButton = Calculator.querySelector ('[data-action = clear]')
  clearButton.textContent = 'CE'
}  

  if (action === 'вычислить') {
  пусть firstValue = калькулятор.dataset.firstValue
  Оператор const = Calculator.dataset.operator
  пусть secondValue = отображаетсяNum
  
  if (firstValue) {
    if (previousKeyType === 'вычислить') {
      firstValue = displayNum
      secondValue = Calculator.dataset.modValue
    }
    
    display.textContent = вычислить (firstValue, оператор, secondValue)
  }
  
  Calculator.dataset.modValue = secondValue
  Calculator.dataset.previousKeyType = 'вычислить'
}  

  if (action === 'вычислить') {
  пусть secondValue = отображаетсяNum
  
  if (firstValue) {
    if (previousKeyType === 'вычислить') {
      secondValue = Calculator.dataset.modValue
    }
  }
  
  Calculator.dataset.modValue = secondValue
}  

  if (keyType === 'calculate') {
  Calculator.dataset.modValue = firstValue && previousKeyType === 'вычислить'
    ? modValue
    : DisplayNum
}  

  const updateCalculatorState = (ключ, калькулятор) => {
  // Необходимые переменные и свойства
  // 1.ключ
  // 2. калькулятор
  // 3. CalculatedValue
  // 4. displayNum
  // 5. modValue
}  

  const updateCalculatorState = (ключ, калькулятор, вычисленное значение, отображаемое число) => {
  // ...
}

keys.addEventListener ('клик', e => {
  если (e.target.matches ('button')) return
  
  константный ключ = e.target
  const displayNum = display.textContent
  const resultString = createResultString (ключ, отображаемое число, набор данных калькулятора)
  
  display.textContent = resultString
  
  // Передаем необходимые значения
  updateCalculatorState (ключ, калькулятор, resultString, displayNum)
})  

  const updateVisualState = (ключ, калькулятор) => {
  const keyType = getKeyType (ключ)
  Array.from (key.parentNode.children) .forEach (k => k.classList.remove ('находится в депрессии'))
  
  if (keyType === 'operator') ключ.classList.add ('в депрессии')
  
  if (keyType === 'clear' && key.textContent! == 'AC') {
    key.textContent = 'AC'
  }
  
  if (keyType! == 'clear') {
    const clearButton = Calculator.querySelector ('[data-action = clear]')
    clearButton.textContent = 'CE'
  }
}  

  ключей.addEventListener ('клик', e => {
  если (e.target.matches ('button')) return
  константный ключ = e.target
  const displayNum = display.textContent
  
  // Чистые функции
  const resultString = createResultString (ключ, отображаемое число, набор данных калькулятора)
  
  // Обновить состояния
  display.textContent = resultString
  updateCalculatorState (ключ, калькулятор, resultString, displayNum)
  updateVisualState (ключ, калькулятор)
})