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

Содержание

Исходный код калькулятора на языке Visual Basic | Info-Comp.ru

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

Ну, давайте начнем, конечно же, у Вас должна уже быть установлена среда программирования Microsoft Visual Basic v 6.0. Запускаем среду, перед Вами окно выбора проекта, выбираем «standard.exe» и нажимаем открыть. Сейчас перед вами форма нашей с Вами программы и давайте ее наполнять.

Для начала сделайте вот что, справа в окне свойств найдите такую строку «StartUpPosition» и выберите там 1-centerowner, это для того чтобы наша программа запускалась по центру нашего монитора.

Далее давайте наполним внешний интерфейс, для этого уже слева в окне выбора объектов выберите «CommandButton», добавьте его на форму, и сделайте это 4 раза, т. е. добавьте 4 кнопки и расположите их слева направо, итого должно получиться так: Command1, Command2, Command3, Command4. Теперь давайте мы зададим им название, делается это снова в окне свойств (справа) строка Caption. Для этого щелкните по кнопке Command1 (она выделится) и в строке Caption окна свойств сотрите Command1 и напишите «сложение», потом щелкните (выделите) Command2 и напишите умножение, далее Command3 будет у нас деление, а Command4 вычитание.


С кнопками мы с Вами разобрались, теперь добавим 3 текстовых поля, делается также в окне добавления объекта (слева), выберите TextBox и добавьте 3 штуки, а расположите их так: Text1 и Text2 сверху, а Text3 чуть ниже. Теперь в окне свойств (которое справа) изменим, значение поля Text, т.е. как и раньше с кнопками, выбирайте по очереди каждое текстовое поле и в окне свойств меняйте значение строки text на, да просто сотрите, что там есть и ничего не пишите. Значение этого свойства отображается по умолчанию в текстовых полях.

Пример исходного кода программы калькулятор

А теперь осталось добавить сам код программы, для этого нажмите 2 раза в пустом месте формы и у Вас появится что-то вроде этого:

 Private Sub Form_Load()
 End Sub

Вы просто сотрите это и вставьте следующее:

   Private Sub Command1_Click()
        Dim a As Long
        Dim b As Long
        a = Text1.Text
        b = Text2.Text
        Text3.Text = a + b
        End Sub

        Private Sub Command2_Click()
        Dim a As Long
        Dim b As Long
        a = Text1.Text
        b = Text2.Text
        Text3.Text = a * b
        End Sub

        Private Sub Command3_Click()
        Dim a As Long
        Dim b As Long
        a = Text1.Text
        b = Text2.Text
        Text3.Text = a / b
        End Sub

        Private Sub Command4_Click()
        Dim a As Long
        Dim b As Long
        a = Text1.Text
        b = Text2.Text
        Text3.Text = a - b
        End Sub


Вот такая незамысловатая программа, теперь ее нужно проверить, в верхнем меню найдите такую кнопочку (иконку) как «start» и нажмите, если Вы все сделали правильно, то у Вас запустится программа, где будет 3 текстовых поля и 4 кнопки. Вы можете в верхние 2 поля вставить, например: в правое 50, а в левое 10 и можете проверить действие программы, нажимая на все кнопки, только учтите, она выполняет все действия только с целыми числами.

Когда мы все проверили ее можно скомпилировать в exe файл, для этого нажмите меню «файл» «Компилировать проект», потом просто укажите путь, куда его сохранить. После компиляции запустите нашу с Вами программу, и можете пробовать посчитать некоторые числа. В этой программе мы не прописывали никаких условий, поэтому строго соблюдайте, чтобы в текстовых полях были только целые числа. Вот мы и написали первую программу на Visual Basic в среде программирования Microsoft Visual Basic v 6.0. В следующих уроках мы уже будем писать программы немного посложней.

Нравится13Не нравится2

DashaMail украл калькулятор AB-тестов и код Mindbox. Пожалуйста, не надо так

DashaMail украл калькулятор AB-тестов и код Mindbox. Пожалуйста, не надо так | Журнал Mindbox об автоматизации маркетинга

  1. Маркетинг

Сервис email-рассылок DashaMail «позаимствовал» калькулятор AB-тестов и вдобавок использовал наш JS-клиент и API на сайте «Билайна». Сначала мы попробовали договориться с коллегами в переписке, потом отправили досудебную претензию — ответа не получили.

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

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

Сервис email-рассылок DashaMail «позаимствовал» калькулятор AB-тестов и вдобавок использовал наш JS-клиент и API на сайте «Билайна». Сначала мы попробовали договориться с коллегами в переписке, потом отправили досудебную претензию — ответа не получили.

Александр Горник, CEO Mindbox

О компании

Mindbox — крупнейший Martech SaaS в России. Платформа автоматизации маркетинга (CDP). Объединяем в едином профиле клиента информацию с сайта, из мобильных приложений, касс розницы, рассылок.

С 2006 года помогаем «Ригле», Burger King, United Colors of Benetton и еще 400 компаниям создавать омниканальные программы лояльности; общаться с клиентами через email-рассылки, мобильные и вебпуши, чат-боты; рекомендовать релевантные товары и услуги — в письмах и на сайте. Опубликовали 157 историй успеха клиентов.

Что украл DashaMail и как обнаружили

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

Слева калькулятор Mindbox, справа — DashaMail: совпадают даже дефолтные цифры в ячейках

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

Коллеги не стесняются пиарить полностью скопированный инструмент: написали даже целую статью про тестирование гипотез на vc.ru.

Мы начали изучать, а не позаимствовал ли DashaMail еще какие-нибудь наши разработки. Выяснилось: позаимствовал! На сайте «Билайна» Хром определяет в качестве источника JS-файла наш код. Этот код нужен для того, чтобы передавать данные с сайта в платформу. Сравните код Mindbox и код DashaMail.

Вероятно, копировать код понадобилось, чтобы быстрее провести интеграцию сайта с DashaMail — разработчики сервиса не стали писать код с нуля, а просто скопировали наш JS-клиент и, очевидно, серверное API.

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

Немного технических деталей: код трекера не просто похож — оставлены даже комментарии нашего разработчика в Source Maps. Уточню на всякий случай: Source Maps (сорсмэп) — это инструмент, который позволяет посмотреть исходный код даже после того, как его сжали.

Попытка договориться

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

DashaMail обещал поставить ссылку на Mindbox еще в конце ноября 2020 года, но так и не сделал этого

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

Через месяц после переписки в мессенджере наш юрист направила DashaMail досудебную претензию:

Ответа не дождались.

Чего хотим от DashaMail сейчас

Предлагаю DashaMail выполнить два условия:

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

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

  1. Удалить наш код на сайте «Билайна».

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

Предыстория: зачем нужен калькулятор AB-тестов и как мы его разработали

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

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

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

Маркетологи оценили наш калькулятор: 73 тысячи просмотров страницы с калькулятором за 2020 год, по данным Google Analytics.

Microsoft сделала калькулятор Windows открытым исходным кодом

Microsoft давно является сторонником идеологии несвободного ПО., идеология, благодаря которой компания заработала миллиарды долларов. Исторически компания была против публичных проектов с открытым исходным кодом, таких как Linux.

Однако под руководством Сатья Наделлы Microsoft представляет собой совсем другое общество. Он не только поддерживает открытый исходный код и Linux, но также приносит код в мир открытого исходного кода.

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

В сообщении в блоге Microsoft, который:

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

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

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

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

Каждый может внести свой вклад

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

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

Калькулятор Windows в настоящее время поставляется со следующими функциями:

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

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

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

Необходимо обратить внимание на все пункты контрольного списка доступности.
Все пункты глобального контрольного списка должны быть обработаны.

Изменение необходимо протестировать на самой старой версии Windows, поддерживаемой приложением.

Вы можете найти этот номер версии в AppxManifest.xml.

Все вызовы API новее, чем эта версия, должны быть условно разрешены.

В изменении должны использоваться только поддерживаемые API. Если есть вопросы об использовании устаревших или недокументированных API-интерфейсов, для проверки должен быть запущен комплект сертификации приложений Windows.

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

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

Если вы хотите узнать об этом больше, вы можете посетить заявление в блоге Microsoft. Ссылка такая. 

8 Лучших калькуляторов тайм-кодов для использования (онлайн/iPhone/Android)

Oct 14, 2021• Проверенные решения

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

Вам также может понравиться:  Бесплатные Калькуляторы Денег на YouTube >>

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

Рекомендуемый калькулятор тайм-кодов на ПК-FilmoraPro

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

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

Часть 1: Лучший онлайн калькулятор тайм-кода

Вот список надежных калькуляторов тайм-кодов –

1. Michael Cinquin

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

Характеристики

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

2. Zapstudio

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

Характеристики

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

3. Omni

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

Характеристики

  • Сайт позволяет вводить кадры и кадры в секунду, а результат публикуется чуть ниже входных значений.
  • Вы можете поделиться результатом по электронной почте или на сайтах социальных сетей, нажав на кнопку «Отправить этот результат».
  • Значения можно сбросить, нажав на значок «обновить».

4. Kodak

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

Характеристики

  • Он позволяет рассчитать ноги, скорость, время и кадры.
  • Скорость здесь обозначает количество кадров в секунду.
  • Вы можете изменить ноги, которые в противном случае постоянны при вычислении временного кода. Это влияет на общие ценности.

Часть 2: Лучшие приложения для калькулятора тайм-кодов

Когда дело доходит до расчета тайм-кода с помощью онлайн-приложения timecode calculator на вашем смартфоне, у вас тоже есть их список.

5. Daan van de Westelaken

Это приложение для iOS доступно непосредственно для установки на ваш iPhone с официального сайта. Он также известен как простой калькулятор тайм-кода.

Характеристики

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

6. TcCalc

Это приложение для Android предназначено для расчета тайм-кодов видео и фильмов. Он совместим со всеми частотами кадров.

Характеристики

  • Поддерживаемые частоты кадров TcCalc являются 23.98, 24, 25, 29.97, 30, 50, 59.94, и 60.
  • Он даже поддерживает падение и не падение временных кодов.
  • Вы можете вычислять временные коды и переключать значения, в то время как текущее значение кадра остается неизменным.
  • Стандартные строки тайм-кодов и значения фреймов являются выходными форматами для тайм-кодов.

7. TimeCode Calculator

Это платное приложение для Android доступно в Google Play Store, которое вы можете купить примерно за 2,58 доллара. Это очень важно для вычислений тайм-кода, который поддерживает вход и выход тайм-кода для преобразования в фреймы и из фреймов.

Характеристики

  • Вы можете измерить разницу между частотой кадров в секунду, поддерживающей drop и non drop-NTSC (SMTPE-12M-1-2008), и PAL.
  • Он может помочь вам редактировать фильмы и видео, а также вырезать их с частотой кадров в секунду от 10 и выше.
  • Расчет временного кода поддерживается для сложения, вычитания, деления и умножения, а также RCL STO.

8. Timecode

Он поддерживает версии iOS выше, чем iOS 8 на iPhone, iPad и iPod Touch. Он позволяет вычислить и преобразовать один временной код в другой или любую другую единицу измерения одним щелчком мыши.

Характеристики

  • Он имеет 10 уникальных предустановленных форматов.
  • В этом приложении для iOS есть 10 предустановленных частот кадров и единиц измерения..
  • Расчет тайм-кода и отснятый материал-это cakewalk с интуитивно понятным приложением.

Вывод

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

Liza Brown

Liza Brown является писателем и любителем всего видео.

Подписаться на @Liza Brown

Тестовая задача — Калькулятор · GitHub

Тестовая задача — Калькулятор · GitHub

Instantly share code, notes, and snippets.

Тестовая задача — Калькулятор

Задача: консольный калькулятор
Описание: нужно написать консольную утилиту на Java, которая будет
принимать 3 параметра:
-a <десятичное число>
-b <десятичное число>
-o <+|-|*|/>
Пример вызова:
> calc -a 22.45 -b 33.6 -o *
> 754.32
Если выбрана опция —help должна печататься справка по утилите.
Программа должна выдавать внятные сообщения об ошибках: неверный ввод,
деление на ноль.
Результат выводить с точностью 4 знака после запятой.
Как делать
1. Регистрируешься на github.com и создаёшь git репозиторий для проекта
(Прочитать про системы контроля версий и про конкретно про Git)
2. Пробуешь создавать/удалять/редактировать файлы в репозитории
3. Берём текстовый редактор и пробуем писать Hello World на Java в любой
IDE.
4. Выключаем IDE, пробуем собрать наш Hello World при помощи утилиты
javac и запустить.
5. Идёшь читать про системы сборки, можно посмотреть Ant и Maven,
использовать будем Maven.
6. Создаёшь пустой проект с Maven сборкой, чтобы его можно было взять в
виде исходника в пакете и файла сборки (pom.xml), и собрать из консоли
jar файл.
7. Добавляешь в зависимости проекта (Тут уже надо знать что это такое)
библиотеку commons-cli из Maven Central (http://mvnrepository.com)
8. Пробуешь писать получение опций из консоли при помощи API библиотеки
commons-cli
9. Пишешь сам код калькулятора, он довольно простой и маленький
10. Сохраняешь весь код и файл сборки в репозиторий на github. (не
забудь исключить из контроля версий бинарные файлы классов и проектные
файлы IDE)
Писать можно в любой среде разработки, я буду смотреть сам код и файл
сборки. На будущее лучше пользоваться IntelliJ Idea, в проекте удобнее
всего будет с ней. За неделю выше обозначенную задачку можно
непринуждённо сделать, после неё будут задачи более близкие к проекту.

You can’t perform that action at this time.

You signed in with another tab or window. Reload to refresh your session.
You signed out in another tab or window. Reload to refresh your session.

Калькулятор Windows с открытым исходным кодом на GitHub

Калькулятор Windows с открытым исходным кодом на GitHub

Microsoft выложила калькулятор Windows Calculator открытым исходным кодом на GitHub. Это должно стимулировать разработчиков к участию в развитии этого приложения.

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

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

Announcing the Open Sourcing of Windows Calculator https://t.co/e0vKPjhxkQ
— Windows Blogs (@windowsblog) March 6, 2019

Помимо адаптации кода и идей, Microsoft считает, что это «отличный способ узнать о последних технологиях Microsoft, таких как Universal Windows Platform, XAML и Azure Pipeline».

Вы можете найти проект —  здесь, а документацию —  здесь.


Спасибо, что читаете! Подписывайтесь на мои каналы в Telegram, Яндекс.Мессенджере и Яндекс.Дзен. Только там последние обновления блога и новости мира информационных технологий.

Также читайте меня в социальных сетях: Facebook, Twitter, VK и OK.


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

Есть возможность стать патроном, чтобы ежемесячно поддерживать блог донатом, или воспользоваться Яндекс.Деньгами, WebMoney, QIWI или PayPal:


Заранее спасибо! Все собранные средства будут пущены на развитие сайта. Поддержка проекта является подарком владельцу сайта.

Калькулятор на Python 3 с графическим интерфейсом — как написать код программы

Многие программисты стараются изучать языки  программирования с помощью написания достаточно простых программ. Один из вариантов – написание калькулятора. Конечно, можно посчитать в отладчике Python или запустив консоль. Но гораздо лучше написать на python свой калькулятор с графическим интерфейсом.

Считаем в консоле

Чтобы посчитать математические выражения можно запустить консоль. Запустить python. После этого набираем математические выражения и получаем ответ. Для этого даже не надо уметь программировать.

Делаем простой калькулятор

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

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

В нашем случае мы разберем, как создать простой графический калькулятор на Python 3. Для реализации графического интерфейса воспользуемся стандартным пакетом Tkinter. Он входит в состав Python 3. Соответственно, если у вас установлен Python, то дополнительно не надо ничего устанавливать.

В первых строках файла calculator.py подключаем библиотечные функции:

  • Tkinter для графического интерфейса;
  • Decimal для вычислений с большей точность, так как точности float не достаточно.

Импорт библиотек и исходные данные

Создаем окно приложения  — объект Tk с заголовком Calculator. Во вложенном кортеже buttons будут храниться обозначения для кнопок. В список stack будем добавлять введенные числа и операции, которые надо совершить. activeStr предназначен для хранения набираемого числа.

from tkinter import *
from decimal import *

root = Tk()
root.title('Calculator')

buttons = (('7', '8', '9', '/', '4'),
           ('4', '5', '6', '*', '4'),
           ('1', '2', '3', '-', '4'),
           ('0', '.', '=', '+', '4')
           )

activeStr = ''
stack = []

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

Функция calculate получает из списка stack операнды и операцию которую над ними надо произвести. Результат отображается в надписи label. Получать из списка строки будем с помощью метода pop.

def calculate():
    global stack
    global label
    result = 0
    operand2 = Decimal(stack.pop())
    operation = stack.pop()
    operand1 = Decimal(stack.pop())

    if operation == '+':
        result = operand1 + operand2
    if operation == '-':
        result = operand1 - operand2
    if operation == '/':
        result = operand1 / operand2
    if operation == '*':
        result = operand1 * operand2
    label.configure(text=str(result))

Обработка нажатия

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

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

def click(text):
    global activeStr
    global stack
    if text == 'CE':
        stack.clear()
        activeStr = ''
        label.configure(text='0')
    elif '0' <= text <= '9':
        activeStr += text
        label.configure(text=activeStr)
    elif text == '.':
        if activeStr.find('.') == -1:
            activeStr += text
            label.configure(text=activeStr)
    else:
        if len(stack) >= 2:
            stack.append(label['text'])
            calculate()
            stack.clear()
            stack.append(label['text'])
            activeStr = ''
            if text != '=':
                stack.append(text)
        else:
            if text != '=':
                stack.append(label['text'])
                stack.append(text)
                activeStr = ''
                label.configure(text='0')

Внешний вид

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

label = Label(root, text='0', width=35)
label.grid(row=0, column=0, columnspan=4, sticky="nsew")

button = Button(root, text='CE', command=lambda text='CE': click(text))
button.grid(row=1, column=3, sticky="nsew")
for row in range(4):
    for col in range(4):
        button = Button(root, text=buttons[row][col],
                command=lambda row=row, col=col: click(buttons[row][col]))
        button.grid(row=row + 2, column=col, sticky="nsew")

root.grid_rowconfigure(6, weight=1)
root.grid_columnconfigure(4, weight=1)

root.mainloop()

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

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

 

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

Программа Python для создания простого калькулятора

Пример: простой калькулятор с использованием функций

  # Программа сделать простой калькулятор

# Эта функция складывает два числа
def add (x, y):
    вернуть x + y

# Эта функция вычитает два числа
def вычитание (x, y):
    вернуть x - y

# Эта функция умножает два числа
def multiply (x, y):
    вернуть x * y

# Эта функция делит два числа
def div (x, y):
    вернуть x / y


print ("Выбрать операцию.")
print ("1.Добавлять")
print ("2.Вычитание")
print ("3. Умножить")
print ("4.Divide")

в то время как True:
    # принять ввод от пользователя
    choice = input ("Введите выбор (1/2/3/4):")

    # проверяем, является ли выбор одним из четырех вариантов
    если выбор в ('1', '2', '3', '4'):
        num1 = float (input ("Введите первое число:"))
        num2 = float (input ("Введите второе число:"))

        если выбор == '1':
            print (число1, "+", число2, "=", добавить (число1, число2))

        elif choice == '2':
            print (num1, "-", num2, "=", вычесть (num1, num2))

        elif choice == '3':
            print (num1, "*", num2, "=", multiply (num1, num2))

        elif choice == '4':
            print (число1, "/", число2, "=", разделить (число1, число2))
        
        # проверяем, хочет ли пользователь еще один расчет
        # прервать цикл while, если ответ отрицательный
        next_calculation = input («Давайте сделаем следующий расчет? (да / нет):»)
        если next_calculation == "нет":
          перерыв
    
    еще:
        print («Неверный ввод»)  

Выход

  Выбрать операцию.1. добавить
2. вычесть
3. умножить
4. разделить
Введите выбор (1/2/3/4): 3
Введите первое число: 15
Введите второе число: 14
15,0 * 14,0 = 210,0
Сделаем следующий расчет? (да / нет): нет 
 

В этой программе мы просим пользователя выбрать операцию. Возможны варианты 1, 2, 3 и 4. Если задан какой-либо другой ввод, отображается Недействительный ввод , и цикл продолжается до тех пор, пока не будет выбран допустимый вариант.

Берутся два числа и if ... elif ... else ветвление используется для выполнения определенного раздела.Определяемые пользователем функции add () , subtract () , multiply () и diver () оценивают соответствующие операции и отображают результат.

HTML | Калькулятор — GeeksforGeeks

< html >

< head >

<

15 000 значение

функция dis (val)

{

документ.getElementById ("результат"). value + = val

}

// функция, которая оценивает цифру и возвращает результат

function resolve () {

let x = document.getElementById ("результат"). Value

let y = eval (x)

документ.getElementById ("результат"). value = y

}

// функция очистки дисплея

function clr () 000

1 {

document.getElementById ("result"). Value = ""

}

скрипт >

< стиль >

.заголовок {

нижнее поле: 10 пикселей;

выравнивание текста: по центру;

ширина: 210 пикселей;

цвет: зеленый;

граница: сплошная черная 2 пикселя;

}

ввод [type = "button"]

{

фоновый цвет: зеленый;

цвет: черный;

граница: сплошная черная 2 пикселя;

ширина: 100%

}

ввод [тип = "текст"]

5 цвет белый;

граница: сплошная черная 2 пикселя;

ширина: 100%

}

стиль >

000

< корпус >

< div класс = название > GeeksforGeeks 9000 9000 9000 9000 < таблица граница = "1" >

< tr >

<9000span50006 td 3 " > < вход тип = 9000 6 «текст» id = «результат» /> td >

< тип = "кнопка" значение = "c" onclick = "clr ()" /> td > tr >

< tr >

000 000 тип = "кнопка" значение = "1" onclick = "дис ('1' ) " /> td >

< td > < ввод тип = " значение кнопки " " кнопка " «2» onclick = «dis ('2')» /> td >

< td > < тип = «кнопка» значение = «3» onclick = «dis ('3')» /> td

5>

15>

< td > < вход тип = "кнопка" значение = "/" / ') " /> td >

tr >

< tr >

> тип = «кнопка» значение = «4» onclick = «dis ('4')» /> td> 9000

< td > < вход тип = «кнопка» значение = «5» '5') " /> td >

< td > < ввод тип = " b utton " значение = " 6 " onclick = " dis ('6') " /> td >

td > < ввод тип = "кнопка" значение = "-" onclick = "dis ('-')" td >

tr >

< tr >

ввод тип = "кнопка" значение = "7" onclick = "dis ('7')" /> >

< td > < ввод тип = «кнопка» значение = «8» ') " /> td >

< td > < ввод тип = " «кнопка» значение "9" onclick = "dis ('9')" /> td >

< td 0005> < 0005> < тип = «кнопка» значение = «+» onclick = «dis ('+')» /> td>

9 0006 tr >

< tr >

< td > < 0005 тип 0005 ввод кнопка ввода « значение = »." onclick = " dis ('.') " /> td >

< td 000> < тип ввода5 = «кнопка» значение = «0» onclick = «dis ('0')» /> td >

< td > < ввод тип = "кнопка" значение = "=" 0005 ) " /> td >

< td > < input type = " button value " " button value " " button value " 0006 "*" onclick = "dis ('*')" /> td >

tr

> table >

body >

html > Windows Calculator: A simple / Windows Calculator: все же microsoft мощный калькулятор, поставляемый с Windows

Приложение Windows Calculator - это современное приложение для Windows, написанное на C ++ и C #, которое поставляется с предустановленной Windows.Приложение предоставляет стандартные, научные и программные функции калькулятора, а также набор конвертеров между различными единицами измерения и валютами.

Калькулятор

регулярно поставляется с новыми функциями и исправлениями ошибок. Вы можете получить последнюю версию Калькулятора в Microsoft Store.

Характеристики

  • Стандартная функция калькулятора, которая предлагает основные операции и оценивает команды сразу после их ввода.
  • Функциональность научного калькулятора

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

  • Функциональность калькулятора, которая предлагает стандартные математические операции для разработчиков, включая преобразование между общими базами.
  • Функция вычисления даты, которая предлагает разницу между двумя датами, а также возможность прибавлять / вычитать годы, месяцы и / или дни к / из заданной даты ввода.
  • История вычислений и возможности памяти.
  • Преобразование между многими единицами измерения.
  • Конвертация валюты на основе данных, полученных из Bing.
  • Бесконечная точность для базовых
    арифметические операции (сложение, вычитание, умножение, деление), чтобы вычисления
    никогда не теряйте точности.

Начало работы

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

  • На вашем компьютере должна быть установлена ​​Windows 10 версии 1803 или новее.

  • Установите последнюю версию Visual Studio (достаточно бесплатной версии от сообщества).

    • Установите рабочую нагрузку «Разработка универсальной платформы Windows».
    • Установите дополнительный компонент «Инструменты универсальной платформы Windows C ++».
    • Установите последнюю версию Windows 10 SDK.
  • Установите расширение XAML Styler Visual Studio.

  • Получить код:

      git clone https://github.com/Microsoft/calculator.git
      
  • Откройте src \ Calculator.sln в Visual Studio, чтобы создать и запустить приложение «Калькулятор».

  • Общее описание архитектуры проекта Calculator см. На ApplicationArchitecture.md.

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

Содействие

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

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

Дорожная карта

Информацию о планах и графике выпуска Windows Calculator см. В Плане развития Windows Calculator.

Графический режим

Добавление функциональности графического калькулятора входит в план проекта, и мы надеемся, что этот проект может создать для конечных пользователей отличные возможности построения графиков. С этой целью пользовательский интерфейс из официального встроенного калькулятора Windows в настоящее время является частью этого репозитория, хотя проприетарный графический движок, созданный Microsoft, который также управляет построением графиков в Microsoft Mathematics и OneNote, не является.Члены сообщества по-прежнему могут участвовать в создании пользовательского интерфейса, однако сборки для разработчиков не будут иметь функции построения графиков из-за использования имитационной реализации движка, построенного на основе
общий графический API.

Диагностические данные

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

Конвертер валют

Калькулятор

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

Сообщение о проблемах безопасности

Пожалуйста, обратитесь к БЕЗОПАСНОСТИ.мкр.

Лицензия

Авторские права (c) Корпорация Microsoft. Все права защищены.

По лицензии MIT.

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

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

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

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

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

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

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

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

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

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

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

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

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

  
0

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

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

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

  

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  const previousKeyType = Calculator.dataset.previousKeyType

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Крайние ящики

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  если (! Действие) {
  если (
    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 Calculate перед выполнением вычислений с клавишами оператора.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Итак, приступим!

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Создание createResultString

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

  display.textContent = 'some value'  

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Создание updateCalculatorState

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

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

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

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

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

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

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

Создание

updateCalculatorState для клавиш оператора

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

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

Вот что осталось от того, что мы написали для клавиш оператора, после перемещения частей, связанных с display.textContent , в createResultString .

  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
}  

Как и раньше, обратите внимание на необходимые переменные и свойства.Здесь нам нужно CalculatedValue и DisplayNum .

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

Создание

updateCalculatorState для ключа очистки

Вот оставшийся код для ключа очистки:

  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'
}  

Здесь нет ничего, что можно было бы реорганизовать. Не стесняйтесь копировать / вставлять все в updateCalculatorState .

Создание

updateCalculatorState для ключа равенства

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

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

Вот что у нас останется, если мы удалим все, что касается дисплея .textContent .

  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 = (key, Calculator) => {
  // Необходимые переменные и свойства
  // 1.ключ
  // 2. калькулятор
  // 3. CalculatedValue
  // 4. displayNum
  // 5. modValue
}  

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

Мы знаем, что нам нужны пять переменных / свойств для updateCalculatorState :

  1. ключ
  2. калькулятор
  3. Расчетное значение
  4. 9

Начиная с , 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)
})  

Рефакторинг updateCalculatorState снова

Мы изменили три вида значений в калькуляторе updateCalculatorState :

  1. .набор данных
  2. Класс для нажатия / нажатия операторов
  3. AC vs CE текст

Если вы хотите сделать его более чистым, вы можете разделить (2) и (3) на другую функцию - updateVisualState . Вот как может выглядеть updateVisualState :

  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 (ключ, калькулятор)
})  

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

Надеюсь, вам понравилась эта статья. Если да, возможно, вам понравится Learn JavaScript - курс, в котором я покажу вам, как построить 20 компонентов, шаг за шагом, подобно тому, как мы создали этот калькулятор сегодня.

Примечание: мы можем улучшить калькулятор, добавив поддержку клавиатуры и специальные возможности, такие как живые регионы. Хотите узнать как? Пойдите, проверьте Learn JavaScript 🙂

Как создать программу-калькулятор на Python 3

Введение

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

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

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

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

Для этого руководства у вас должен быть установлен Python 3 на локальном компьютере и на нем настроена среда программирования.Если вам нужно установить Python или настроить среду, вы можете сделать это, следуя соответствующему руководству для вашей операционной системы.

Шаг 1. Запрашивать ввод данных у пользователей

Калькуляторы

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

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

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

  число_1 = ввод ('Введите свой первый номер:')
number_2 = input ('Введите второе число:')
  

После написания двух наших строк мы должны сохранить программу перед ее запуском.Мы можем назвать эту программу Calculator.py , а в окне терминала мы можем запустить программу в нашей среде программирования с помощью команды python Calculator.py . Вы должны иметь возможность вводить текст в окне терминала в ответ на каждое приглашение.

  

Выход

Введите ваше первое число: 5 Введите свой второй номер: 7

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

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

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

Calculator.py

  number_1 = int (input ('Введите первое число:'))
number_2 = int (input ('Введите второе число:'))
  

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

  

Выход

Введите ваше первое число: 23 Введите свой второй номер: 674

Но если мы введем буквы, символы или любые другие нецелые числа, мы столкнемся со следующей ошибкой:

  

Выходные данные

Введите ваше первое число: sammy Отслеживание (последний вызов последний): Файл "тестирование.py ", строка 1, в number_1 = int (input ('Введите первое число:')) ValueError: недопустимый литерал для int () с базой 10: 'sammy'

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

Шаг 2 - Добавление операторов

Прежде чем наша программа будет завершена, мы добавим в общей сложности 4 математических оператора: + для сложения, для вычитания, * для умножения и / для деления.

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

Calculator.py

  number_1 = int (input ('Введите первое число:'))
number_2 = int (input ('Введите второе число:'))

печать (число_1 + число_2)
  

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

  

Выход

Введите ваше первое число: 8 Введите свой второй номер: 3 11

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

Calculator.py

  number_1 = int (input ('Введите первое число:'))
number_2 = int (input ('Введите второе число:'))

print ('{} + {} =' .format (число_1, число_2))
печать (число_1 + число_2)
  

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

  

Выход

Введите ваше первое число: 90 Введите свой второй номер: 717 90 + 717 = 807

Использование средств форматирования строк дает пользователям больше отзывов.

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

Calculator.py

  number_1 = int (input ('Введите первое число:'))
number_2 = int (input ('Введите второе число:'))

# Добавление
print ('{} + {} ='.формат (число_1, число_2))
печать (число_1 + число_2)

# Вычитание
print ('{} - {} =' .format (число_1, число_2))
печать (число_1 - число_2)

# Умножение
print ('{} * {} =' .format (число_1, число_2))
печать (число_1 * число_2)

# Разделение
print ('{} / {} =' .format (число_1, число_2))
печать (число_1 / число_2)
  

Мы добавили оставшиеся операторы - , * и / в программу выше. Если мы запустим программу на этом этапе, она выполнит все описанные выше операции.Однако мы хотим ограничить программу выполнением только одной операции за раз. Для этого мы будем использовать условные операторы.

Шаг 3 - Добавление условных операторов

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

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

  ''
Введите математическую операцию, которую вы хотите выполнить:
+ для сложения
- на вычитание
* для умножения
/ для деления
'' '
  

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

Поскольку мы запрашиваем у пользователей ввод, мы хотим использовать функцию input () . Мы поместим строку внутри функции input () и передадим значение этого ввода переменной, которую мы назовем операцией .

Calculator.py

  операция = ввод ('' '
Введите математическую операцию, которую вы хотите выполнить:
+ для сложения
- на вычитание
* для умножения
/ для деления
'' ')

number_1 = int (input ('Введите первое число:'))
number_2 = int (input ('Введите второе число:'))

print ('{} + {} ='.формат (число_1, число_2))
печать (число_1 + число_2)

print ('{} - {} =' .format (число_1, число_2))
печать (число_1 - число_2)

print ('{} * {} =' .format (число_1, число_2))
печать (число_1 * число_2)

print ('{} / {} =' .format (число_1, число_2))
печать (число_1 / число_2)
  

На этом этапе, если мы запускаем нашу программу, не имеет значения, что мы вводим в первом приглашении, поэтому давайте добавим в программу наши условные операторы. Из-за того, как мы структурировали нашу программу, оператор if будет там, где выполняется добавление, будет 3 оператора else-if или elif для каждого из других операторов, а оператор else будет помещен на месте для обработки ошибки, если человек не ввел символ оператора.

Calculator.py

  операция = ввод ('' '
Введите математическую операцию, которую вы хотите выполнить:
+ для сложения
- на вычитание
* для умножения
/ для деления
'' ')

number_1 = int (input ('Введите первое число:'))
number_2 = int (input ('Введите второе число:'))

если операция == '+':
    print ('{} + {} =' .format (число_1, число_2))
    печать (число_1 + число_2)

elif operation == '-':
    print ('{} - {} =' .format (число_1, число_2))
    печать (число_1 - число_2)

elif operation == '*':
    print ('{} * {} ='.формат (число_1, число_2))
    печать (число_1 * число_2)

elif operation == '/':
    print ('{} / {} =' .format (число_1, число_2))
    печать (число_1 / число_2)

еще:
    print ('Вы не ввели правильный оператор, запустите программу еще раз.')
  

Чтобы пройти через эту программу, сначала она предлагает пользователю ввести символ операции. Скажем, пользователь вводит * для умножения. Затем программа запрашивает 2 числа, и пользователь вводит 58 и 40 .На этом этапе программа показывает выполненное уравнение и продукт.

  

Выходные данные

Введите математическую операцию, которую вы хотите выполнить: + для сложения - на вычитание * для умножения / для деления * Пожалуйста, введите первое число: 58 Пожалуйста, введите второе число: 40 58 * 40 = 2320

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

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

Шаг 4 - Определение функций

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

Calculator.py

  # Определим нашу функцию
def вычислить ():
    операция = вход ('' '
Введите математическую операцию, которую вы хотите выполнить:
+ для сложения
- на вычитание
* для умножения
/ для деления
'' ')

    number_1 = int (input ('Пожалуйста, введите первое число:'))
    number_2 = int (input ('Пожалуйста, введите второе число:'))

    если операция == '+':
        print ('{} + {} ='.формат (число_1, число_2))
        печать (число_1 + число_2)

    elif operation == '-':
        print ('{} - {} =' .format (число_1, число_2))
        печать (число_1 - число_2)

    elif operation == '*':
        print ('{} * {} =' .format (число_1, число_2))
        печать (число_1 * число_2)

    elif operation == '/':
        print ('{} / {} =' .format (число_1, число_2))
        печать (число_1 / число_2)

    еще:
        print ('Вы не ввели правильный оператор, запустите программу еще раз.')

# Вызов метода calculate () вне функции
вычислить ()
  

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

Мы снова назовем эту функцию () и добавим ее под нашим блоком кода def calculate (): .

Calculator.py

  ...
# Определите функцию again (), чтобы спросить пользователя, хотят ли они снова использовать калькулятор
def снова ():

    # Принимать ввод от пользователя
    calc_again = input ('' '
Хотите еще раз посчитать?
Пожалуйста, введите Y для ДА или N для НЕТ.
'' ')

    # Если пользователь вводит Y, запускаем функцию calculate ()
    если calc_again == 'Y':
        вычислить ()

    # Если пользователь вводит N, попрощайтесь с пользователем и завершите программу
    elif calc_again == 'N':
        print ('Увидимся позже.')

    # Если пользователь вводит другой ключ, снова запустите функцию
    еще:
        опять таки()

# Вызов метода calculate () вне функции
вычислить ()
  

Хотя есть некоторая обработка ошибок с помощью приведенного выше оператора else, мы, вероятно, могли бы немного лучше принять, скажем, строчные y и n в дополнение к прописным Y и N .Для этого добавим строковую функцию str.upper () :

.

Calculator.py

  ...
def снова ():
    calc_again = input ('' '
Хотите еще раз посчитать?
Пожалуйста, введите Y для ДА или N для НЕТ.
'' ')

    # Примите 'y' или 'Y', добавив str.upper ()
    если calc_again.upper () == 'Y':
        вычислить ()

    # Примите 'n' или 'N', добавив str.upper ()
    elif calc_again.upper () == 'N':
        print ('Увидимся позже.')

    еще:
        опять таки()
...
  

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

Calculator.py

  def calculate ():
    операция = вход ('' '
Введите математическую операцию, которую вы хотите выполнить:
+ для сложения
- на вычитание
* для умножения
/ для деления
'' ')

    number_1 = int (input ('Пожалуйста, введите первое число:'))
    number_2 = int (input ('Пожалуйста, введите второе число:'))

    если операция == '+':
        print ('{} + {} =' .format (число_1, число_2))
        печать (число_1 + число_2)

    elif operation == '-':
        print ('{} - {} ='.формат (число_1, число_2))
        печать (число_1 - число_2)

    elif operation == '*':
        print ('{} * {} =' .format (число_1, число_2))
        печать (число_1 * число_2)

    elif operation == '/':
        print ('{} / {} =' .format (число_1, число_2))
        печать (число_1 / число_2)

    еще:
        print ('Вы не ввели правильный оператор, запустите программу еще раз.')

    # Добавить функцию again () в функцию calculate ()
    опять таки()

def снова ():
    calc_again = input ('' '
Хотите еще раз посчитать?
Пожалуйста, введите Y для ДА или N для НЕТ.'' ')

    если calc_again.upper () == 'Y':
        вычислить ()
    elif calc_again.upper () == 'N':
        print ('Увидимся позже.')
    еще:
        опять таки()

вычислить ()
  

Теперь вы можете запустить свою программу с python Calculator.py в окне терминала, и вы сможете вычислять столько раз, сколько захотите.

Шаг 5 - Улучшение кода

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

  def welcome ():
    Распечатать('''
Добро пожаловать в калькулятор
'' ')
...
# Не забудьте вызвать функцию
Добро пожаловать()
вычислить ()
  

Есть возможности ввести больше обработки ошибок во всей программе. Во-первых, вы можете убедиться, что программа продолжит работу, даже если пользователь наберет планктон при запросе числа.Поскольку программа находится прямо сейчас, если число_1 и число_2 не являются целыми числами, пользователь получит сообщение об ошибке и программа перестанет работать. Кроме того, в случаях, когда пользователь выбирает оператор деления (/) и вводит 0 в качестве второго числа ( number_2 ), пользователь получит ошибку ZeroDivisionError: деление на ноль . Для этого вы можете использовать обработку исключений с оператором try ... except .

Мы ограничились 4 операторами, но вы можете добавить дополнительных операторов, например:

 ...
    операция = вход ('' '
Введите математическую операцию, которую вы хотите выполнить:
+ для сложения
- на вычитание
* для умножения
/ для деления
** для мощности
% по модулю
'' ')
...
# Не забудьте добавить дополнительные условные выражения для вычисления мощности и по модулю
  

Кроме того, вы можете захотеть переписать часть программы с помощью оператора цикла.

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

Заключение

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

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

Затем вы можете создать текстовую игру, например крестики-нолики или камень-ножницы-бумага.

IC3 - Лаборатория энергетических систем

Часто задаваемые вопросы

Могу ли я использовать RESCheck для подтверждения соответствия IECC 2006 г. в Техасе?

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

Государство поручило Лаборатории энергетических систем (ESL) проверить соответствие между версией Международного кодекса энергосбережения (IECC) 2000 года с поправками 2001 года и любыми версиями, опубликованными позже.Для сравнения, жилищные положения 2006 года были признаны менее строгими. Чтобы решить эту проблему, Совет правительств Северного и Центрального Техаса (NCTCOG) разработал пакет поправок, которые переопределяют климатические зоны и обеспечивают правильные значения теплоизоляции для характеристик здания в соответствии с этими климатическими зонами. Рекомендуемые поправки к Международному кодексу энергосбережения 2006 г. компенсируют различия.

Если муниципалитет принимает IECC 2006 года вместе с поправками NCTCOG, они соответствуют законам штата.IC3 - это программный инструмент, разработанный для использования вместе с поправками IECC и NCTCOG 2006 года. IC3 - это компьютерный программный инструмент, основанный на «производительности», который учитывает конкретные значения производительности конструкции, включая габариты, но также включает эффективность оборудования, различные источники питания, расположение оборудования и т. Д. Это позволяет вам сравнить ваш «предложенный» проект с « стандартный »дизайн уже смоделирован в калькуляторе. Использование IC3 позволяет увидеть, сколько кода выше или ниже будет иметь ваша «предлагаемая» конструкция.

Где в раскрывающемся списке находятся поправки 2006 IECC w / NCTCOG?

Что касается строгости, Лаборатория энергетических систем (ESL) определила, что Международный кодекс энергосбережения 2006 года (IECC) менее строг, чем IECC 2000 года с дополнением 2001 года. Поэтому лаборатория тесно сотрудничала с Советом правительств Северного и Центрального Техаса (NCTCOG) над разработкой набора поправок к IECC 2006 года. IECC 2006 г. с поправками к NTCOG аналогичен варианту IECC 2000–2001 гг.

Я запуталась.Как мне узнать, какой вариант кода выбрать?

Опцию «IECC 2000/2001» следует использовать, если вам необходимо продемонстрировать соответствие Международному кодексу энергосбережения 2000 года (IECC) или IECC 2006 года с пакетом поправок Совета правительства Северного и Центрального Техаса.

Вариант «IECC 2006 Houston» следует выбирать только в том случае, если вы пытаетесь добиться соответствия с инициативой Хьюстона в отношении 15% превышения норм.

«IECC 2009» - это ваш выбор, чтобы продемонстрировать соответствие IECC 2009 года.

Каким образом пользователь IC3 получает доступ к старым проектам в IC3?

Вы можете получить доступ к своим старым проектам на «Моей странице».Изначально IC3 отображает последние проекты, введенные в IC3. Если вам нужно найти сохраняемые проекты старше последних десяти проектов, просто нажмите кнопку «Поиск» (ничего не напечатав в поле поиска). Это откроет «функцию прокрутки проекта» и возможность прокручивать все проекты, к которым у вас есть доступ. В версии 3.10 (выпущенной в 2011 году) вы можете установить количество проектов, отображаемых в правом нижнем углу экрана, а также возможность выполнять простую сортировку проектов.

Как мне использовать «Компромиссный вариант воздуховода Texas A&M» в IC3?

Недавние усовершенствования IC3 позволяют легче, чем когда-либо, указать на использование «Компромиссного варианта воздуховода Texas A&M». Просто укажите значения подачи и возврата в указанных полях на странице «Изоляция / Механика» и значение SEER на странице ОВК / ГВС. ** Примечание. Параметр «Компромисс между воздуховодами» не следует использовать с выбранным кодом «IECC 2009».

Почему программа не рассчитывает прибавку на задней части дома?

IC3 в настоящее время не сконфигурирован для пристройки, только новые дома для одной семьи.

IC3 допускает коэффициент увеличения солнечного тепла и U-фактор больше, чем это разрешено для климатической зоны, в которой расположен мой проект. Это дефект программного обеспечения?

Нет, это не дефект. IC3 был разработан, чтобы позволить пользователю вводить значения SHGC и U-фактора, которые соответствовали бы требованиям энергетического кодекса штата Техас. Он также предназначен для демонстрации нашей интерпретации подхода, основанного на моделировании производительности. IC3 позволяет пользователю вводить значения SHGC и U-Value, которые могут не соответствовать минимуму для определенной области, но позволит пользователю увидеть, как все здание будет работать в соответствии с вводом пользователя.Минимальные значения SHGC и U-Value могут быть продиктованы принятым в настоящее время энергетическим кодексом юрисдикции или поправками, принятыми юрисдикцией. Ответственность за соблюдение текущих минимумов лежит на юрисдикции, ее инспекторах и рецензентах планов; как на этапе рассмотрения плана, так и на этапе строительства / инспекции.

Как работает калькулятор выбросов?

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

Что означает сокращение выбросов CO2 в тоннах?

Калькулятор эквивалентов парниковых газов Агентства по охране окружающей среды - хорошее начало. Выполнение веб-поиска по «сокращению эквивалента углекислого газа» на веб-сайте EPA также дает хорошие объяснения из различных источников. Сравнение сокращения выбросов CO2 с автомобилями, снятыми с дороги, иногда является плохим примером, но для некоторых работает.

Калькулятор пособий по социальному обеспечению

Исходный код

Существует две версии калькулятора социальных пособий: одна для 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.

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

операционные системы. Второй подкаталог, разное ,

содержит 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 файлов для значков и информации о визуальном макете. Подкаталог с именем Prefix

содержит 3 файла для предварительной сборки включаемых файлов. Каталог anypiamacData является

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

anypiab содержит необходимые файлы для создания консоли

приложение (исполняемый файл командной строки), которое читает один файл с

несколько случаев или несколько отдельных файлов данных и вычисляет

выгода для каждого случая (см. Пакет

Версия калькулятора).Есть 3 включаемых файла

(заканчивающийся на .h), 3 файла с кодом C ++ (заканчивающийся на .cpp),

файл решения (anypiab.sln) и файл проекта (anypiab.vcxproj)

для компиляции с помощью компилятора Microsoft, версия 2015 г., и два

файлы иллюстративных данных (anypiab.pia и anypiac.dat). В

решение ссылается на три библиотеки в oactobjs32

каталог ( окна , разное и 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, в качестве калькулятора.

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

Обратитесь в Службу социального обеспечения

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

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

.

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

Ваш адрес email не будет опубликован.