C калькулятор консоль: Калькулятор C# в консоли — Программирование на C, C# и Java

Управление окнами приложений на Mac

Когда на Mac открыто приложение или Finder, на рабочем столе отображается соответствующее окно. В каждый момент времени активно только одно приложение; название активного приложения (выделенное жирным шрифтом) и различные меню приложения отображаются в строке меню.

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

Перемещение, выравнивание и объединение окон приложений

На Mac можно сделать следующее.

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

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

  Окно занимает выбранную сторону экрана; строка меню и Dock остаются по‑прежнему видны.

  Чтобы вернуть предыдущие местоположение и размер окна, при нажатой клавише Option наведите указатель на зеленую кнопку, затем выберите «Вернуть».

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

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

• Объединение окон приложения в одном окне со вкладками. В приложении выберите пункт меню «Окно» > «Объединить все окна». Если для приложения доступно несколько видов окон (например, для приложения «Почта» доступны окно просмотра и окно нового письма), можно объединять только окна активного типа.

  Чтобы снова сделать вкладку отдельным окном, выберите эту вкладку, затем выберите меню «Окно» > «Переместить вкладку в новое окно» или просто перетяните вкладку за пределы окна. См. раздел Использование вкладок в окнах.

Разворачивание и сворачивание окон приложений

На Mac можно выполнять следующие действия с окнами.

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

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

• Сворачивание окна. Нажмите желтую кнопку сворачивания  в левом верхнем углу окна или нажмите сочетание клавиш Command-M.

  В разделе настроек «Строка меню и Dock» можно задать сворачивание окна двойным нажатием его заголовка.

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

Быстрое переключение между окнами приложений

На Mac можно сделать следующее.

• Переключение на предыдущее приложение. Нажмите сочетание клавиш Command-Tab.

• прокрутка всех открытых приложений: Удерживая клавишу Command, нажмите клавишу Tab, затем выберите нужное приложение, нажимая клавиши со стрелками влево и вправо. Отпустите клавишу Command.

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

Закрытие одного окна или всех окон приложения

На Mac можно сделать следующее.

• Закрытие одного окна. В окне нажмите красную кнопку «Закрыть»  в левом верхнем углу окна или нажмите сочетание клавиш Command-W.

• Закрытие всех открытых окон приложения. Нажмите сочетание клавиш Option-Command-W.

Закрытие одного или всех окон приложения не приводит к завершению этого приложения. Небольшая точка под значком приложения в Dock показывает, что приложение продолжает работать. Чтобы завершить приложение, нажмите Command-Q. См. раздел Завершение приложений.

Можно скрыть активное приложение, нажав Command-H.

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

VK Cloud Solutions | ИТ-платформа бизнес-класса от VK

Виртуальныесерверы

Вычислительные ресурсы в облаке для высокой доступности цифровых сервисов любой сложности

Виртуальныесети

Объединение серверов в локальных сетях, Public & Private DNS, VPN, распределение нагрузки и фильтрация трафика

Объектноехранилище

Неограниченное хранение и передача массива данных по S3 API. Обработка тысяч запросов в секунду

КластерыKubernetes

Сертификация CNCF

Автомасштабирование и ускорение доставки приложений с Kubernetes как сервисом

Стабильность работы и высокая доступность управляемых СУБД. Быстрый запуск готового сервиса

Большиеданные

Обработка и анализ больших данных с облачной инфраструктурой на базе Apache Hadoop, Spark, ClickHouse

Высоко­производительные вычисления в облаке и обучение нейросетей с NVIDIA® Tesla

Машинноеобучение

Удобное рабочее место аналитика с ML-песочницами. API компьютерного зрения

Создание IoT-приложений с набором готовых компонентов для анализа данных реального времени

Kaspersky Endpoint Security для бизнеса Стандартный | Защита рабочих мест

Многоуровневая защита

Kaspersky Endpoint Security для бизнеса Стандартный сочетает в себе технологии для защиты всех устройств на любой платформе от многочисленных, постоянно меняющихся киберугроз. Инструменты контроля, автоматическая защита от эксплойтов, система предотвращения вторжений и другие функции существенно снижают вероятность заражения вредоносным ПО. Другие технологии и процессы обнаруживают и распознают вредоносное ПО на рабочих местах, блокируют его активность и производят автоматический откат действий, выполненных вредоносной программой до ее блокировки.

Сочетание передовых технологий и глубокой аналитики

Уникальный подход HuMachine, созданный «Лабораторией Касперского», — это сочетание анализа «больших данных», машинного обучения и обширного экспертного опыта. Все это помогает успешно противодействовать сложным новейшим атакам и обеспечивает высокий уровень обнаружения угроз.

Интеграция с облачной базой данных

Миллионы пользователей во всем мире добровольно и анонимно предоставляют со своих компьютеров в Kaspersky Security Network (KSN) данные об угрозах. Эта облачная сеть собирает и хранит огромные объемы метаданных о подозрительных файлах. Такие сведения, поступающие в реальном времени, позволяют защищать корпоративную сеть от новейших угроз, в том числе атак нулевого дня.

Выявление подозрительного поведения

В Kaspersky Endpoint Security для бизнеса Стандартный и на стадии, предшествующей исполнению файла, и во время исполнения файла используется поведенческий анализ. Эта функция поддерживается облачной сетью Kaspersky Security Network, в которой хранится огромный объем метаданных о подозрительных файлах.
До запуска файла выявление подозрительного поведения с использованием эмуляции играет критическую роль в определении неизвестных и комплексных угроз. Когда приложение запускается в корпоративной сети, компонент Анализ поведения отслеживает его активность. Заметив подозрительное поведение, компонент автоматически блокирует приложение, а с помощью компонента Откат вредоносных действий может производиться автоматическая отмена всех действий, уже совершенных вредоносным ПО. Это эффективный механизм борьбы с программами-шифровальщиками.

Автоматическая защита от эксплойтов

Не существует приложений или операционных систем, в которых бы полностью отсутствовали уязвимости. Уязвимости могут эксплуатироваться вредоносным ПО для проникновения в корпоративную сеть, заражения рабочих станций и серверов и нарушения бизнес-процессов компании. Инновационная технология автоматической защиты от эксплойтов (AEP) не позволяет вредоносному ПО использовать уязвимости в операционных системах или приложениях, работающих в сети. AEP отслеживает работу приложений, которые чаще всего становятся жертвами вредоносного ПО – Adobe Reader, Internet Explorer, Microsoft Office, Java и многих других, – чтобы обеспечить дополнительный уровень мониторинга безопасности и защиты от неизвестных угроз.

Блокирование сетевых атак

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

Защита общих папок от шифрования

Приложения Kaspersky Endpoint Security для Windows, Kaspersky Endpoint Security для Linux и Kaspersky Security для Windows Server содержат уникальный механизм Анти-Криптор, который блокирует шифрование общих файловых ресурсов вредоносным процессом, выполняемым на другом компьютере в той же сети. Приложения постоянно наблюдают за защищенными общими папками, отслеживая состояние хранящихся в них файлов. При обнаружении шифрования система блокирует доступ к серверу для компьютера – источника атаки, останавливая процесс шифрования и предотвращая потерю корпоративных данных.

Мебельная фурнитура и комплектующие для мебели MAKMART

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

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

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

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

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

MAKMART – качество, в котором не приходится сомневаться

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

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

Складская программа MAKMART насчитывает более 15 000 наименований продукции и более 50 товарных групп. Отбираем лучших поставщиков для Вас. Это более 120 фабрик-производителей из Европы: Италия, Германия, Испания, Соединённое Королевство, Австрия, Польша и др., а также России и Юго-Восточной Азии.

Только проверенные бренды с безупречной репутацией: SALICE, CAMAR, INOXA, CITTERIO GIULIO, FURNIPART, GIUSTI, FAB GROUP, SERVETTO, GOLLINUCCI, DOMUS LINE и др.

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

• Огромный выбор фурнитуры, аксессуаров и кухонных принадлежностей, который постоянно пополняется
• Удобно структурированный каталог с полной технической информацией и профессиональными иллюстрациями
• Товары в наличии благодаря обширной складской программе
• Только проверенные бренды и сертифицированные товары высокого качества
• Доставка во все регионы России
• Обширная сеть филиалов и дилеров, шоу-румы и склады в крупных городах РФ и Ближнего Зарубежья
• Профессиональные консультации и сервисы для мебельщиков

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

Введение в разработку графического интерфейса

Для выполнения программы в среде IDE выполните следующие действия:

1. Выберите Run («Запуск») > Run Main Project («Запуск главного проекта») (как вариант, нажмите F6).

Примечание. При открытии окна с указанием того, что для Project NumberAddition не задан основной класс, следует выбрать my.NumberAddition.NumberAdditionUI в качестве основного класса в том же окне и нажать кнопку ОК.

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

1. Для сборки архива JAR приложения выберите «Run > Clean and Build Main Project» (Shift-F11).

2. При помощи проводника по файловой системе или диспетчера файлов перейдите в каталог ` NumberAddition/dist`.

Примечание. Местоположение каталога проекта NumberAddition зависит от пути, указанного при создании проекта в шаге 3 в разделе Упражнение 1. Создание проекта.

1. Дважды щелкните файл NumberAddition.jar.

Через несколько секунд приложение запустится.

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

Можно также запустить приложение из командной строки.

Для запуска приложения из командной строки выполните следующие действия:

1. Вызовите командную строку или окно терминала.

2. В командной строке измените текущий каталог на каталог NumberAddition/dist.

3. В командной строке введите следующий оператор:

java -jar  NumberAddition.jar

Примечание. Убедитесь, что my.NumberAddition.NumberAdditionUI задан как основной класс до запуска приложения. Для провери этого, щелкните правой кнопкой узел мыши узел проекта NumberAddition на панели ‘Проекты’, выберите ‘Свойства’ во всплывающем меню и выберите категорию ‘Выполнить’ в диалоговом окне ‘Свойства проекта’. В поле ‘Основной класс’ должно отображаться my.numberaddition.NumberAdditionUI .

Ruby за двадцать минут

Вступление

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

Интерактивный Ruby

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

Откройте IRB (сокращение для Interactive Ruby).

• Если вы используете macOS, откройте Terminal, наберите irb и нажмите Enter.
• Если вы используете Linux, откройте shell, наберите irb и нажмите Enter.
• Если вы используете Windows, откройте Interactive Ruby из секции Ruby вашего меню Пуск.

irb(main):001:0>

Окей, итак он запущен. Что дальше?

Наберите это: "Hello World"

irb(main):001:0> "Hello World"
=> "Hello World"

Ruby повиновался вам!

Что только что произошло? Неужели мы только что написали кратчайшую в мире программу “Hello World”? Не совсем. Вторая строка, это всего-лишь способ IRB показать нам результат последнего выполненного выражения. Если мы хотим напечатать “Hello World”, мы должны написать немного больше:

irb(main):002:0> puts "Hello World"
Hello World
=> nil

puts – основная команда в Ruby, позволяющая напечатать что-нибудь. Но что же такое тогда => nil? Это результат выполнения выражения. puts всегда возвращает nil, который в Ruby обозначает значение абсолютно-положительного ничего.

Ваш бесплатный калькулятор

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

irb(main):003:0> 3+2
=> 5

Три плюс два. Достаточно просто. Что насчет три умножить на два? Вы можете набрать сами, это достаточно короткий код, но также вы можете вернуться выше и изменить то, что вы ввели ранее. Попробуйте нажать стрелку наверх на клавиатуре и вы увидите строку с 3+2. Если это так — вы можете использовать стрелку влево, чтобы переместить курсор прямо за +, нажать backspace и поменять его на *.

irb(main):004:0> 3*2
=> 6

Теперь давайте попробуем возвести три в квадрат:

irb(main):005:0> 3**2
=> 9

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

irb(main):006:0> Math.sqrt(9)
=> 3.0

Окей, погодите, что это было? Если вы думаете “это был способ выяснить квадратный корень из девяти”, вы правы. Но давайте приглядимся к деталям. Во-первых, что такое Math?

Модули группируют код по темам

Math – это встроенный модуль для математических операций. Модули выполняют две роли в Ruby. Наш пример показывает первую роль: сгруппировать похожие методы вместе под знакомым именем. Math также содержит методы типа sin() и tan().

Следующее – это точка. Что делает точка? Точка – это то, как вы указываете получателя сообщения. Что такое сообщение? В данном случае это sqrt(9), которое означает вызов метода sqrt, сокращение от “square root” (квадратный корень), с параметром 9.

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

Что если мы хотим запомнить результат какой-либо математической операции? Присвойте это значение переменной.

irb(main):007:0> a = 3 ** 2
=> 9
irb(main):008:0> b = 4 ** 2
=> 16
irb(main):009:0> Math.sqrt(a+b)
=> 5.0

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

Калькулятор подбора Volcano | Online калькулятор количества Волкано

По умолчанию — калькулятор настроен на расчет-подбор количества тепло-вентиляторов в режиме «ОТОПЛЕНИЕ». В этом режиме, производится подсчет необходимого количества тепла (тепловой мощности) для обогрева Вашего помещения в период средней Зимней температуры (например «-25»), до желаемой (например «+20»)

Для смены режима — измените температуру на входе в тепло-вентиляторы в диапазоне от «+5» до «+20» (вкладка «ПАРАМЕТРЫ»). В этом режиме, производится подсчет необходимого количества тепла (тепловой мощности) для догрева Вашего помещения до желаемой температуры(например «+20») в период средней Зимней температуры (например «-25»), с учетом, что Ваше существующее отопление уже обеспечивает определенный уровень положительной температуры, (например «+5»).

В некоторых случаях сложной конфигурации помещений необходимо обязательное проведение подробного теплового расчета здания, который должен быть выполнен специалистами нашего проектного отдела. Для дополнительной консультации по расчету и проектированию свяжитесь с нами по телефону: 8 (977) 705 45 22​, 8-977-880-14-76.

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

Поэтому, в случае известных Вам источников тепла в Вашем помещении, экономически целесообразно, полученное в нашем КАЛЬКУЛЯТОРЕ значение тепловой мощности (как и количество тепло-вентиляторов) — уменьшить, на величину тепловой мощности от прочих известных источников тепла.

Как же можно экономить на топливе для котловых систем (газ, дизель, дрова, пеллеты) при отоплении воздухонагревателями VOLCANO, по сравнению с системами отопления с обычными батареями и регистрами? VOLCANO применяются при температуре теплоносителя (воды или незамерзайки) от 50 до 120 град, а для функционирования аппараты используют воздух, циркулирующий в самом отапливаемом помещении. Чем теплее в помещении — тем меньшая мощность тепловой энергии требуется тепловентилятору для поддерживания заданной температуры. При использовании не дорогой автоматики, поддерживая в помещении температуру от +5 до +30, тепло-вентиляторы Volcano выполняют еще несколько полезных задач: непрерывно перемешивают воздух в помещении для исключения не прогретых зон при помощи сверхмощного и экономичного вентилятора и равномерно распределяют теплый воздух при помощи регулируемых жалюзи на выходе аппарата. Благодаря поворотной консоли (крепежа) горячий воздух может быть направлен в любую часть помещения куда по техническим характеристикам аппарата.

Тепловентиляторы Volcano существуют нескольких видов по мощности от 3 до 75 кВт, по длине струи от 14 до 26м, по объему прокачиваемого воздуха от 2000 мкуб до 5700 мкуб. Тепло-вентиляторы Volcano VR и V (EuroHeat) применяются для малых (офисы, кафе, котельные), для средних (гаражи, боксы, торговые точки), и крупных (стадионы, спортзалы, торговые центры, автосалоны) помещений. Главная их особенность — молниеносный, в течение 5-10 минут обогрев любого помещения с высокой эффективностью. Многочисленные примеры объектов по всей России, позволяют с уверенностью сказать, что Тепло-вентиляторы Volcano VR и V подходят для подавляющего большинства помещений, исключение составляют помещения с особыми требованиями к искробезопасности, поскольку двигатель всех аппаратов (Volcano VR mini V25, VR1, V45, VR2, VR3) имеет только защиту IP54.

Применение современной автоматики для управления аппаратами Volcano VR и V позволяет автоматически или в ручном режиме отапливать помещение любого объема и степени утепления. Однако, следует понимать, что чем более утепленное у Вас помещение, тем меньшее количество тепло-вентиляторов Вам потребуется для поддержания внутри помещения комфортной температуры. В 80% случаев, проведенные при помощи нашего калькулятора расчеты, позволяют оценить экономический эффект от применения нашего отопления, и позволяют закупить в 2-3 раза меньшее количество Volcano (чем при подборе тепловентиляторов нашими «Партнерами»), потратив остаток денег на улучшение утепления Вашего помещения.

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

Отдельное применение тепло-вентиляторы Volcano нашли на автомойках. Именно для автомоек, влажных помещений, помещений с высокой степенью безответственности работников (могут сломать сложную систему управления) мы приводим в результатах расчета — автоматику IP54. Несколько простых правил при установке ВОЛКАНО ВР, позволяют отапливать мойки и гаражи, особенно в северных регионах. Благодаря своим уникальным характеристикам Volcano VR и V за несколько секунд отогревают заледеневший автомобиль, затем, после окончания мойки — так же быстро его высушивают. Автомобиль выезжает из Вашей автомойки — полностью сухим и остатки воды не замерзают на сибирском морозе. В это сложно поверить, но это факт, мы готовы предоставить Вам подтверждение в виде выполеннных проектов автомоек по всей России. Ни один другой вид отопления, ни инфракрасное, ни вентиляция, ни батареи с регистрами не способны на такой эффект!

Принцип действия тепло-вентиляторов очень прост. Для обогрева помещения, аппарат засасывает через заднюю решетку двигателя воздух из помещения и, пропустив его через нагретый до температуры теплоносителя теплообменник, выдувает подогретый воздух на расстояние от 1м до 26м (регулировка потока осуществляется автоматикой). Чем более мощный тепловой поток выбрасывает аппарат, тем более быстро прогревается помещение, и чем более высокая температура теплоносителя, тем более экономично применение тепло-вентиляторов. Граница экономической выгоды от использования тепло-вентиляторов — 50 град. Volcano — самый простой способ обогреть помещение с минимумом затрат.

Несмотря на использование не по назначению, тепло-вентиляторы VOLCANO (EuroHeat) в Российских реалиях, применяются в помещениях с небольшим содержанием вредных веществ. Позволяет это делать корпус тепловентиляторов, у Volcano VR1 и VR2 (старого поколения, а также у VOLCANO mini, VR1, VR2, VR3 нового поколения) выполненный из пластика устойчивого к разрушению в агрессивных средах, а у Volcano V20(mini), Volcano V25 и Volcano V45 из вспененного полипропилена, который дополнительно обеспечивает 100% отсутствие тепловых потерь через корпус и исключает любое повреждение аппаратов при небрежном обращении с ними. Беззащитен перед агрессивной средой — только теплообменник тепло-вентиляторов (срок службы сокращается до 2-3 лет), выполенный из высококачественного медно-бронзового сплава с алюминиевыми ламелями.

Методичка к калькулятору подбора тепловентиляторов Volcano VR1/VR2/VR3 и mini

Пять команд для использования калькулятора в командной строке Linux

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

Я несколько раз использовал команду bc при создании LVM для вычисления значений PE.

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

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

• bc: Базовый калькулятор, используемый для базовой математики.
• calc: Это альтернатива bc.
• gcalccmd: — консольная версия утилиты Gnome Calculator.
• qalc: — это консольная версия калькулятора Qalculate.
• expr & echo: Команда Linux используется для очень простых математических вычислений.

1) Как произвести расчет в Linux с помощью команды bc?

bs означает «Базовый калькулятор» . Он предлагает вам все, что вы ожидаете от научного, финансового или даже простого калькулятора.

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

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

 $ sudo dnf install bc [ Fedora и CentOS / RHEL 8 ]
$ sudo apt install bc [ Ubuntu / Debian ]
$ sudo pacman -S bc [ Arch Linux / Manjaro ]
$ sudo yum install bc [ CentOS / RHEL 6/7 ]
$ sudo zypper install bc [ openSUSE Leap ] 

1.a) Как использовать команду bc

Просто введите «bc» на своем терминале, чтобы запустить команду bc и использовать следующие символы для расчета:

• Плюс: Сложение
• Минус: Вычитание
• Прямая косая черта: Деление
• Звездочка: Используется для умножения

Тип 'quit' для выхода из bc, когда вы сделано.

 $ до н.э.
до н.э. 1.07.1
Авторские права 1991-1994, 1997, 1998, 2000, 2004, 2006, 2008, 2012-2017 Free Software Foundation, Inc.
Это бесплатное программное обеспечение, на которое не распространяется АБСОЛЮТНО БЕЗ ГАРАНТИЙ.
Для получения подробной информации введите "гарантия".

1 + 2
3

10-5
5

2 * 5
10

10/2
5

(2 + 4) * 5-5
25

выйти из 

Используйте флаг « -l » для определения стандартной математической библиотеки:

 $ bc -l
до н.э. 1.07.1
Авторские права 1991-1994, 1997, 1998, 2000, 2004, 2006, 2008, 2012-2017 Free Software Foundation, Inc.
Это бесплатное программное обеспечение, на которое не распространяется АБСОЛЮТНО БЕЗ ГАРАНТИЙ.Для получения подробной информации введите "гарантия".

3/5
.60000000000000000000

выйти из 

2) Как использовать терминал Linux в качестве калькулятора с командой calc?

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

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

Для систем «Fedora» и «RHEL / CentOS 8» используйте команду dnf для установки calc:

 $ sudo dnf установить calc 

Для систем на базе «Debian / Ubuntu» используйте команду apt для установки calc:

 $ sudo apt установить apcalc 

Для систем на базе «Arch Linux» используйте команду pacman для установки calc:

 $ sudo pacman -S calc 

Для систем «RHEL / CentOS 6/7» используйте команду yum для установки calc:

 $ sudo yum установить calc 

Для системы «openSUSE Leap» используйте команду zypper для установки calc:

 $ sudo zypper установить calc 

2.а) Расчеты с командой calc

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

Интерактивный режим:

 $ выч.
Калькулятор произвольной точности в стиле C (версия 2.12.7.1)
Calc - открытое программное обеспечение. Для получения сведений о лицензии введите: help copyright
[Введите «exit», чтобы выйти, или «help», чтобы получить помощь.]

; 5 + 1
6
; 5-1
4
; 5 * 2
10
; 10/2
5
; выйти из 

Неинтерактивный режим:

 $ расчет 3/5
0.6 

3) Как произвести расчет в Linux с помощью команды gcalccmd?

gnome-Calculator — официальный калькулятор среды рабочего стола GNOME, тогда как ‘gcalccmd’ — консольная версия утилиты Gnome Calculator. По умолчанию он установлен на рабочем столе GNOME, независимо от вашего дистрибутива.

3.a) Команда gcalccmd для выполнения вычисления

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

Примечание. Чтобы выйти из команды gcalccmd, нажмите «Ctrl + d» или введите «выйти»

 $ гкалккмд

> 5 + 1
6

> 5-1
4

> 5 * 2
10

> 10/2
5

> sqrt (16)
4

> 3/5
0,6

>  бросить  

4) Как произвести расчет в Linux с помощью команды qalc?

Qalc — это консольная версия калькулятора Qalculate, которая используется как универсальный калькулятор. Он прост в использовании, но предоставляет универсальные функции.

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

 $ sudo dnf install libqalculate [ Fedora и CentOS / RHEL 8 ]
$ sudo apt install libqalculate [ Ubuntu / Debian ]
$ sudo pacman -S libqalculate [ Arch Linux / Manjaro ]
$ sudo yum install libqalculate [ CentOS / RHEL 6/7 ]
$ sudo zypper install libqalculate [ openSUSE Leap ] 

4.a) команда qalc для выполнения вычислений

Я добавил несколько примеров, чтобы продемонстрировать это:

 $ кальк
> 5 + 1

  5 + 1 = 6

> ANS * 2

  ANS * 2 = 12

> анс-2

  ANS - 2 = 10

> 1 доллар в рупиях
  1 * доллар = прибл.73 06961 индийская рупия
  
> 1 SGD в INR
  1 * SGD = прибл. 54,49 1817 индийских рупий

> выйти из 

5) Как выполнить базовый расчет в Linux с помощью команды expr & echo?

Если вы просто хотите выполнить базовые вычисления, вам не нужно устанавливать какое-либо приложение-калькулятор в вашей системе. Вы можете сделать это в оболочке bash, используя команды expr & echo.

Оба включены в пакет «coreutils» , который предустановлен почти во всех дистрибутивах Linux.

5.а) команда expr для выполнения вычисления

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

Для сложения, вычитания и деления

 $ выраж. 5 + 1
6

$ expr 5 - 1
4

$ expr 10/2
5 

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

 $ выражение 10 \ * 2
20 

5.b) команда echo для выполнения расчета

 $ эхо $ ((5 + 5))
10

$ echo $ ((10-4))
6

$ эхо $ ((10 * 4))
40

$ эхо $ ((10/2))
5 

Завершение

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

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

Создайте простой калькулятор, используя оператор switch case

Дом » .Сеть » Программы на C #

Пример оператора switch case в C # : Здесь мы собираемся разработать простой калькулятор , используя оператор switch case в C # .
Отправлено Панкадж Сингхом 25 декабря 2018 г.

Задача состоит в том, чтобы спроектировать простой калькулятор, используя операторы switch case со следующими операциями:

1. Дополнение
2. Вычитание
3. Умножение
4. А, подраздел

Программа:

 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

пространство имен DecisionMaking3
{
    программа класса
    {
        static void Main (строка [] аргументы)
        {
            Консоль.WriteLine («Калькулятор»);
            Console.WriteLine ("----------------------------");
            Console.WriteLine ("1. Добавить");
            Console.WriteLine ("2. Аннотация");
            Console.WriteLine ("3. Умножить");
            Console.WriteLine ("4.Divide");
            Console.Write ("Введите выбор (1-4):");
            int ch = Int32.Parse (Console.ReadLine ());
            int a, b, c;
            переключатель (ch)
            {
                Дело 1:
                    Консоль.Напишите ("Введите A:");
                    a = Convert.ToInt32 (Console.ReadLine ());
                    Console.Write ("Введите B:");
                    b = Convert.ToInt32 (Console.ReadLine ());
                    с = а + Ь;
                    Console.WriteLine ("Sum = {0}", c);
                    перерыв;
                случай 2:
                    Console.Write ("Введите A:");
                    a = Convert.ToInt32 (Console.ReadLine ());
                    Консоль.Напишите ("Введите B:");
                    b = Convert.ToInt32 (Console.ReadLine ());
                    с = а - б;
                    Console.WriteLine ("Разница = {0}", c);
                    перерыв;
                случай 3:
                    Console.Write ("Введите A:");
                    a = Convert.ToInt32 (Console.ReadLine ());
                    Console.Write ("Введите B:");
                    b = Convert.ToInt32 (Console.ReadLine ());
                    с = а * б;
                    Консоль.WriteLine ("Продукт = {0}", c);
                    перерыв;
                случай 4:
                    Console.Write ("Введите A:");
                    a = Convert.ToInt32 (Console.ReadLine ());
                    Console.Write ("Введите B:");
                    b = Convert.ToInt32 (Console.ReadLine ());
                    c = a / b;
                    Console.WriteLine ("Частное = {0}", c);
                    перерыв;
                дефолт:
                    Консоль.WriteLine («Неверный выбор»);
                    перерыв;
            }
            Console.ReadKey ();
        }
    }
}
 

Выход

 Первый запуск:

Калькулятор
----------------------------
1. добавить
2. аннотация
3. умножить
4. разделить
Введите выбор (1-4): 1
Введите A: 10
Введите B: 20
Сумма = 30


Второй прогон:

Калькулятор
----------------------------
1. добавить
2.Вычитать
3. умножить
4. разделить
Введите выбор (1-4): 4
Введите A: 10
Введите B: 20
Частное = 0


Третий прогон:

Калькулятор
----------------------------
1. добавить
2. аннотация
3. умножить
4. разделить
Введите выбор (1-4): 5
Неверный выбор
 

Основные программы на C # »

TOP Проблемы / вызовы по кодированию интервью!

ОБЪЯВЛЕНИЕ

ОБЪЯВЛЕНИЕ

Исходный код

Существует две версии калькулятора социальных пособий: одна для Windows. и один для MacOS.В версия для Windows скомпилирована с использованием компилятора Microsoft Visual C / C ++ (Версия 2015 г.). Версия для MacOS скомпилирована с помощью Metrowerks. Компилятор CodeWarrior (версия 9.0)

Исходный код калькулятора

Исходный код, который выполняет фактические расчеты выгод, хранится в подкаталоги oactobjs (для MacOS) и oactobjs32 (для Windows).Кроме того, в каждом подкаталоге есть дополнительные файлы, сохраненные компилятор, помогающий компилятору создавать библиотеки; эти файлы отличаются от От Windows до MacOS.

Исходный код оконной части программы хранится в подкаталогах anypiamacprojOSX (для MacOS) и anypia32 (для Windows). Также есть подкаталог anypiab с исходным кодом для создания консольного приложения; он использует расчетный код Windows.(Видеть Пакетная версия калькулятора для подробнее.)

Вы можете загрузить расчетный и оконный код MacOS (подкаталоги oactobjs и anypiamacOSXproj ), и / или расчетный код Windows и оконный код (подкаталоги oactobjs32 , anypia32 и anypiab ). В код для MacOS доступен как.ситекс архивы. В Код Windows доступен в виде самораспаковывающихся заархивированных файлов. (исполняемый на машине Windows) или в виде простых zip-файлов (которые могут быть расширенным в любой операционной системе с возможностью распаковки).

Загрузка исходного кода Windows

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

Загрузка исходного кода MacOS

Чтобы загрузить код MacOS, щелкните каждый из следующих элементов:

В 2006 г.2 и более поздних версиях кода мы используем библиотеки Boost, которые набор бесплатных библиотек с открытым исходным кодом, которые выполняют общие функции, не включены в стандартной библиотеке C ++. Чтобы использовать наш исходный код, у вас будет скачать и установить библиотеки из www.boost.org. На этом веб-сайте есть инструкции по установке библиотек на ваш компьютер. В коде Windows используется 1.64.0 версии библиотек Boost и Версия для Mac использует 1.33.1.

В ваших проектах C ++ для каждой из библиотек в нашем исходном коде и основной программный проект, вы должны указать путь включения к базе вашего Boost установочный каталог. Вот где у нас установлен буст в готовом проекты, которые мы включаем в наш исходный код: На компьютере с Windows библиотеки находятся в подкаталоге из oactobjs32 с именем «boost_1_64_0».На Mac библиотеки находятся в каталог, параллельный oactobjs и anypiamacprojOSX, с именем «boost_1_33_1». Как только это будет сделано, вы можете использовать наши проекты для создания программы.

Каталог oactobjs (для MacOS)

oactobjs содержит 183 включаемых файла (с расширением .h) и четыре подкаталога с исходным кодом библиотеки. Первый подкаталог, miscproj , содержит 38 файлов (с расширением.cpp) для классов, которые специально не привязаны к расчетам пособия по социальному обеспечению. Второй подкаталог, piadataproj , содержит 149 файлов (с расширением .cpp) для классов, связанных с расчетом пособий. Третий подкаталог, piaoutproj , содержит 38 включаемых файлов (заканчивающихся на .h) и 38 файлов (заканчивающихся на .cpp) для классов, включающих распечатку результаты расчета пособия.Четвертый подкаталог, mac , содержит шесть файлов заголовков (заканчивающихся на .h) и один файл (заканчивающийся на .cpp) для функций, которые недоступны в MacOS или отличаются от аналогичных функции в других операционных системах. Код во всех четырех подкаталогах содержит только был протестирован с компилятором Metrowerks в среде MacOS.

Каталог oactobjs32 (для Windows)

oactobjs32 содержит пять подкаталогов с исходными кодами библиотеки. код.Первый подкаталог, windows , содержит 15 включаемых файлов (заканчивающихся на .h), 6 файлов C (заканчивающихся на .c) и 4 файлов C ++ (заканчивающихся на .cpp) для функций, которые недоступны в Windows. операционной системы, или которые отличаются от аналогичных функций в других операционные системы. Второй подкаталог, misc , содержит 31 файл (заканчивающийся на .cpp) для классов, которые не привязаны в частности, для расчетов пособий по социальному обеспечению.Третий подкаталог, piadata , содержит 152 файла (заканчивающиеся на .cpp) для классов, связанных с расчетом пособий. Четвертый подкаталог, piaout , содержит 40 включаемых файлов (окончание в .h) и 40 файлов (заканчивающихся на .cpp) для классов, включающих распечатка результатов расчета пособия. Пятый подкаталог, включает , содержит 182 файла заголовков (кончающийся на .час). Кроме того, каждый подкаталог, кроме include содержит файл решения (заканчивающийся на .sln) и файл проекта (заканчивающийся на .vcxproj), который работает с Microsoft компилятор версии 2015 года для создания каждой библиотеки. Однако код в трех подкаталогах кроме Windows имеет был скомпилирован в прошлом в операционной системе Linux с использованием Компилятор GNU C ++, где подкаталог linux занимает место подкаталога windows .

Каталог anypiamacprojOSX

anypiamacprojOSX содержит пять подкаталогов: один с пользовательским интерфейсом код для MacOS версии программы расчета пособий, один с файлы ресурсов, один с информацией для предварительной сборки включаемых файлов, один для целевого информация и один для вывода. Подкаталог с именем Source содержит 33 включаемых файла. (кончающийся на .h), 31 файл с функциями класса (заканчивающиеся на .cp или .cpp) и 1 файл с служебными функциями (заканчивающимися на .c). Подкаталог с именем Resources содержит 10 файлов для значков и информации о визуальном макете. Подкаталог с именем Префикс содержит 3 файла для предварительной сборки включаемых файлов. Каталог anypiamacData является пусто, но будет содержать целевую информацию после открытия проекта в CodeWarrior.Каталог Output будет содержать исполняемый файл при построении программы.

anypiab содержит необходимые файлы для создания консоли приложение (исполняемый файл командной строки), которое читает один файл с несколько случаев или несколько отдельных файлов данных и вычисляет выгода для каждого случая (см. Пакет Версия калькулятора).Есть 3 включаемых файла (заканчивающийся на .h), 3 файла с кодом C ++ (заканчивающийся на .cpp), файл решения (anypiab.sln) и файл проекта (anypiab.vcxproj) для компиляции с помощью компилятора Microsoft, версия 2015 г., и два файлы иллюстративных данных (anypiab.pia и anypiac.dat). В решение ссылается на три библиотеки в oactobjs32 каталог ( windows , misc и piadata ), поэтому эти библиотеки необходимо создать перед компиляцией файлов в этот подкаталог.Существует макрос с именем DETAILS, который можно определено, чтобы позволить anypiab производить подробный вывод. Если он определен, четвертая библиотека ( piaout ) также должна быть сделано перед компиляцией файлов в этом подкаталоге. В Anypiab программа скомпилирована на других операционных систем, включая Linux с использованием компилятора Gnu C ++ с Библиотека linux , заменяющая библиотеку windows .

anypia32 содержит код пользовательского интерфейса для Windows версия Калькулятора и один подкаталог с ресурсом файлы. Всего 40 включаемых файлов (с расширением .h), 39 файлов с расширением. функции класса (заканчивающиеся на .cpp), файл ресурсов (anypia32.rc), файл решения (anypia32.sln), файл проекта (Anypia32.vcxproj) и файл макроса справки (resource.hm). В Подкаталог res содержит 4 файла для значков и растровых изображений. Решение ссылается на четыре библиотеки в Подкаталог oactobjs32 и библиотеки Boost, так что те библиотеки должны быть созданы перед компиляцией файлов в этом подкаталог.

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

Мы предоставляем описания функций, доступных в oactobjs32 библиотеки в скомпилированном файле справки для Windows и набор HTML-файлы в ситкс-архиве для Mac OSX. Чтобы загрузить документацию, щелкните следующий элемент:

Создание программы с изменениями настоящего закона

Версия интерактивной или консольной программы, которая может обрабатывать некоторые изменения. из настоящего закона могут быть созданы с помощью LawChangeArray, созданного в строке 69 из anypiabdoc.cpp (для консольной версии) или строка 195 AnypiaDoc.cpp (для интерактивная версия для Windows). Обратите внимание, однако, что только некоторые из 40 перечисленных изменения настоящего закона фактически реализованы. Также обратите внимание, что там еще нет кода пользовательского интерфейса для обработки индикаторов изменений с действующий закон.

У нас также есть программа оценки программы социального обеспечения в Фортране, работа которого аналогична версии C ++.Фортран исходный код структурирован аналогично версии C ++, но не был обновлялся несколько лет. Исходный код программы или программы скомпилирован для MS-DOS, доступен в самораспаковывающемся архиве. sourcef.exe (384 000 байт) или в простом заархивированном файле, sourcef.zip (358 085 байт).

Программа компилируется в Windows 98 или NT с использованием Compaq Fortran.Это также отдельные файлы подпрограмм, позволяющие компилировать программу в системе Unix или на мэйнфрейме IBM. Однако в скомпилированной программе нет некоторых возможности обработки экрана версии C ++; поэтому мы распространяем Версия C ++, а не версия Fortran, в качестве калькулятора.

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

Версия консоли калькулятора подсети IPv4

Версия консоли калькулятора подсети IPv4 — это программа, написанная на языке программирования C ANSI и скомпилированная с помощью 32-битного компилятора TDM-GCC MinGW 4.9.2 на DevC ++ IDE . Работает в среде консоли Windows * (CMD.exe) и с некоторыми уже внесенными изменениями кода может быть скомпилирован для использования в операционных системах на базе Linux и консоли Linux.

Разработано с любовью к программированию и в образовательных целях. Срок разработки версии консоли калькулятора подсети IPv4 составлял 6 месяцев вместе с версией приложения GUI WPF и был моим первым погружением в разработку программного обеспечения. Он содержит алгоритмы преобразования чисел (десятичное в двоичное и обратное) с настраиваемыми структурами IPv4 и сложными функциями для вычислений подсети. В нем предусмотрены различные методы ввода, CIDR, функциональность подсетей VLSM и хорошо структурированная консольная система отображения результатов с вниманием к деталям.

IP v4 Консоль калькулятора подсети Разработка версии остановлена ​​в июне 2015 года. Это означает, что программа не тестировалась для профессионального использования, и ошибки все еще существуют. Эта консольная версия Win32 позже преобразована в приложение WPF C # с графическим интерфейсом пользователя с полным рефакторингом кода и с UI Build для нуля со многими исправлениями основных алгоритмов вычисления, а также введением в разделение на подсети IPv6.

Вы можете скачать его и протестировать.

/ * Авторские права © Гулас Атанасиос (TerrorFlatRider) 2014-2015 Все права защищены * /

Функции

• [Пункт меню «1»] Десятичное число Ввод IPv4 (пример: 192.168.1.2)
• [вариант меню «2»] двоичный вход IPv4 (пример: 11000000.10101000.00000001.00000010)

• • [вариант меню «3»] вход Префикс по умолчанию
  • [Опция меню «4»] Ввод Пользовательский префикс
  • [Опция меню «5»] Ввод Максимальное количество хостов
  • [Опция меню «6»] Ввод Максимальное количество подсетей
    
  • [Параметр меню «7»] Введите Маску сети в десятичной форме (пример : 255.255.255.0)
    
  • [Опция меню «8»] Вход Сетевая маска в Двоичная форма ( пример: 11111111.11111111.11111111.00000000)
  • [Меню 9] ] Стандартный режим вычисляет все IP-адреса подсети в последовательности
  • O ption, чтобы ограничить результаты определенным диапазоном подсети.

• [вариант меню «1»] Ввод Пользовательский префикс
• [вариант меню «2»] Ввод Хосты

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

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

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

Системные требования

• * Microsoft Windows XP / 7/8 / 8.1 / 10

Как создать приложение калькулятора 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 , это должен быть цифровой ключ.

  if (! Action) {
  console.log ('цифровой ключ!')
}  

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

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

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

Следуя тому же мыслительному процессу, если ключ 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 (! Action) {
  if (displayNum === '0') {
    display.textContent = keyContent
  }
}  

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

  if (! Action) {
  if (displayNum === '0') {
    display.textContent = keyContent
  } еще {
    display.textContent = displayNum + keyContent
  }
}  

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Чтобы освободить нажатое состояние, мы удаляем класс нажато из всех клавиш через цикл 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. Очистить ключ

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

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

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

включает проверочную строку для данного совпадения. Если строка найдена, она возвращает 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 для каждой нажатой клавиши.

  if (! Action) {
  // ...
  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.

После вычисления результата мы устанавливаем отображение на результат. Затем мы устанавливаем оператор на вычитание и 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 как отображаемое Num

В-пятых, калькулятор вычисляет результат 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 , оператором , нам также нужно проверить, соответствует ли вычисление .

  if (! Action) {
  если (
    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 . Если это не 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
  }
}  

Наконец, обратите внимание на необходимые переменные и свойства.На этот раз нам понадобится калькулятор .dataset.firstValue и калькулятор .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. action
5. firstValue modValue
6. operator

Мы можем получить keyContent и action из key .Мы также можем получить firstValue , modValue , operator и previousKeyType из набора данных калькулятора .

Это означает, что для функции createResultString требуются три переменные: ключ , отображаемый номер Num и набор данных калькулятора . Поскольку 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 === 'calculate') {
  пусть 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 (ключ, калькулятор)
})  

  
 require 'irb' 
 require_relative '../lib/calculator' 
 
 IRB.start 
  

  
 require 'irb' 
 require_relative '../lib/calculator' 
 
 def reload! (Print = true) 
 помещает 'Reloading ...', если print 
 root_dir = File. expand_path ('..', __dir__) 
 reload_dirs =% w {lib} 
 reload_dirs.each do | dir | 
 Dir.glob ("# {root_dir} / # {dir} / ** / *. Rb"). Each {| f | load (f)} 
 end 
 true 
 end 
 
 IRB.start 
  

  $ bin / console
  

  irb (main): 001: 0> calc = Calculator.новый
=> # <Калькулятор: 0x00007fbdae8d4eb0>
irb (main): 002: 0> calc.multiply (2, 3)
Отслеживание (последний вызов последний):
        2: из ./bin/console:20:in `
 '
        1: из (irb): 2
NoMethodError (неопределенный метод `умножения 'для # )
  

  class Calculator 
 def multiply (n1, n2) 
 n1 * n2 
 end 
 
 end 
  

  irb (main): 003: 0> перезагрузить!
Перезарядка ...
=> правда
  

  irb (main): 004: 0> calc.multiply (2, 3)
=> 6