Как составить программу на бейсике

Как составить программу на бейсике

Visual Basic для начинающих – YouTube
Источник

Языки программирования насчитывают несколько десятков вариантов. Какие-то из них подходят для нативной разработки, а какие-то – для кроссплатформенной. Visual Basic – язык программирования, который произошел от более старого языка – Basic.

В данной статье предстоит разобраться с особенностями составления Бейсик программ. Ориентироваться будем на VB, так как он встречается на практике чаще. А еще необходимо выяснить особенности выбранного ЯП и сферы его применения. Эта информация поможет понять, стоит ли вообще начинать изучение Visual Basic (далее он будет называться просто «Бейсик»).

VB – это…

Строки кода для работоспособного программного обеспечения удастся написать на любом выбранном языке. «Бейсик» — полноценный ЯП, а также специальная интегрированная среда разработки. Она была создана корпорацией Microsoft. Это – наследник BASIC с огромным количеством диалектов.

VB предусматривает:

  • процедурное программирование;
  • написание кода при помощи объектно-ориентированных принципов;
  • компонентно-ориентированность.

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

История развития

Сам BASIC появился в 1964 году. В 80-х он стал утрачивать свою актуальность ввиду сложности. Исходный код даже самого элементарного приложения по сравнению с «конкурентами» содержал множество строчек и не выделялся быстродействием.

Все это привело к тому, что разработчики начали задумываться над созданием диалектов BASIC. А компания Microsoft выпустила QBasic, а чуть позже – VB.

Популярность этот язык программирования получил, начиная с версии 3.0, которая позволила взаимодействовать с базами данных. Освоить такой «Бейсик» мог даже рядовой пользователь, далекий от вопросов разработки. Элементарное приложение можно было составить в несколько строк, половина из которых прописывалась автоматически во время использования встроенных инструментов.

Традиционный VB появился в 1998 году – это его последняя версия. Далее, после сборки 6.0, Майкрософт решили разделить язык на несколько векторов. Они стали развиваться VB на платформе .Net, а также адаптированные версии для решения задач локального характера.

Виды VB

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

Классика

Basic Classic – классический VB. Он ориентирован на разработку приложений под Windows. Используется преимущественно как инструмент написания строк кода для соответствующей операционной системы. Предусматривает широкий спектр возможностей и инструментов, ориентированных на программирование под Windows.

Сюда относят:

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

Classic не пишется в отличных от изначальной средах разработки.

VBA

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

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

VBScript

Урезанный вариант Classic. Такой Basic является скриптовым. Он подходит для администрирования на базе Windows. Активно применяется для создания страниц ASP и всевозможных сценариев под IE.

Basic .NET

Вариант, появившийся после версии 6.0 классического VB. Совершенно новый вектор развития от Microsoft. Ориентирован на работу с платформой .NET. Он:

  • использует в работе библиотеку классов из .НЕТ;
  • имеет объектно-ориентированную парадигму;
  • обладает полиморфизмом и строгой типизацией.

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

Особенности

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

Составить элементарную утилиту сможет даже новичок, далекий от принципов разработки. Создание форм осуществляется через drag and drop, который отнимает минимум времени. Достаточно перетащить компонент на экран, а затем присвоить ему строки с теми или иными командами.

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

  1. Объединение операторов. Принцип работает относительно логических и битовых вариантов.
  2. Автоматическое конвертирование целочисленных значений в вещественные. Это происходит после деления.
  3. Объявление массивов при помощи обозначения границ: верхних и нижних. Аналогичные принципы предусматривает Fortran и Pascal.
  4. Объединение VB с COM. Сюда также относится Windows.
  5. Наличие специального типа данных — variant. Он используется для переменных, в которых не указан тип данных.

Язык поддерживает статическую и динамическую строгую типизацию. Является компилируемым и интерпретируемым. За счет совместимости с Windows даже новичок сможет создавать программы с расширением .exe.

Преимущества и недостатки

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

К преимуществам «Бейсика» относят:

  1. Быстрое написание контента, ориентированного на операционные системы Windows.
  2. Наличие защиты от ошибок. Она помогает делать программы стабильными. Этот момент до сих пор часто критикуют.
  3. Возможность применения WnAPI для расширения итогового функционала программ.
  4. Выбор типа компиляции. Строки программы можно скомпоновать в машинный код или P-код в несколько кликов.

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

Недостатки тоже есть:

  1. Ориентированность преимущественно на Mac OS X и Windows. Другие системы не поддерживаются.
  2. Скорость работы. Если сравнивать программы на «Бейсике с визуализацией», то они будут уступать софту, написанному на других языках с ООП.
  3. Отсутствие механизмов наследования реализации имеющихся компонентов. Поддерживается лишь наследование интерфейсов. 

Для того, чтобы строки написанной программы работали на устройстве, потребуется установить на компьютер отдельную библиотеку. А именно – msvbvm.dll.

Основы языка

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

Комментарии

«Бейсик» поддерживает возможность вставки комментариев. Для этого можно использовать или новую строку, или уже имеющуюся. Во втором случае комментарий вставляется после основного кода.

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

Типы данных

Для того, чтобы задать тип данных, нужно использовать оператор Dim, после которого в строке приложения указывается имя. Далее следует ключевое слово As с типом переменной, в противном случае можно обойтись записью Dim имя_переменной. Соответствующий элемент получит тип variant.

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

В VB 6.0 поддерживаются следующие типы данных:

  1. Byte. Нужен для хранения чисел в диапазоне от 0 до 255.
  2. Integer. Целое. Обозначается суффиксом %. Хранит целочисленные от -32 768 до 2 767.
  3. Long. Обозначается в строке как &. Это – «длинное целое».
  4. Single (!). Позволяет задавать переменные с точкой одинарной точности.
  5. Double (#). Числа с плавающей точкой двойной точности.
  6. Decimal (CDec). Масштабируемое целое. Используется для того, чтобы применять десятичное представление чисел в строках.
  7. Boolean. Булевый тип. Хранит только «истину» и «ложь». Используется при работе с логическими операторами.
  8. String ($). Это – строка переменной длины. Помогает хранить строковые и символьные данные.
  9. String*N. Строка постоянной длины.
  10. Date. Тип данных, ориентированный на работу с датой и временем в программе.
  11. Object (Set). Помогает хранить ссылки на объект.
  12. Currency (@). Денежный тип. Имеет до 4 цифр после запятой и до 14 – перед ней.

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

Операторы

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

В данную категорию можно отнести:

  1. Присваивание (=). Помогает присваивать переменным те или иные значения. Может быть задан при помощи ключевого слова Let. Set используется для присвоения переменной объектного типа. ЯП поддерживает многократное присваивание.
  2. Сложение (+).
  3. Умножение (*).
  4. Деление (/).
  5. Вычитание (-).
  6. Степень (^).
  7. Целочисленное деление (). Первое число будет поделено на второе с отбрасыванием дробной части. Округление не производится.
  8. Деление по модулю (Mod). В ходе операции первое число делится на второе. Происходит возврат только остатка от выполненного действия.
  9. Равенство (=).
  10. Больше, чем. Сюда также относят «меньше, чем» (> и <).
  11. Больше или равно и меньше или равно (>= и <=).
  12. Не равно (<>).
  13. Сравнение объектов (Is). Будет определять, ссылаются ли переменные объектного типа на один и тот же элемент или на разные.
  14. Подобие (Like). При применении происходит сравнение строкового объекта с шаблоном. Далее система сообщает, подходит ли этот компонент.
  15. Логическое И (And), ИЛИ (or), отрицание (Not), исключение (Xor).
  16. Эквивалентность (Eqv). Производит оценку эквивалентности двух выражение. Если принцип соблюден, система вернет True.
  17. Импликация (Imp). False возвращается системой, если E1 = True, а E2 = False. В противном случае значение окажется True.

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

Оператор & помогает автоматически преобразовывать выражения и значения в строковый тип. После этого «склеивание» будет производиться без проблем.

О модулях и классах

Бейсик программы хранят исходные коды в виде модулей. Они бывают разного вида:

  1. Формы. Обладают расширением .frm. Выступает такой модуль «базовым» для большинства программ. Содержит процедуры обработки события, общие процедуры, переменные, константы и их виды, внешние операции. При раскрытии формы в обычном текстовом редакторе появляется описание, элементы управления и свойства.
  2. Стандартный. Расширение — .bas. Это – контейнер для операций, функций и объявлений, к которым чаще всего получают доступ другие модули программы. Содержат глобальные и иные переменные, а также соответствующие процедуры. Код, написанный внутри, может не иметь связи с конкретной программой.
  3. Класса (.cls). Это – основа объектно-ориентированной разработки. Позволяет создавать новые объекты. Полученные компоненты могут обладать собственными свойствами, методами, а также событиями.

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

Простая консольная программа

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

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

Начало проекта

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

  1. Запустить Visual Studio.
  2. Кликнуть по кнопке «Создать проект». Это делается в правой части открытого софта.
  3. Выбрать интересующий ЯП.
  4. Определиться с типом операционной системы. Пример – Windows. Далее предстоит указать вид проекта – «Консоль».
  5. Щелкнуть по надписи «Консольное приложение», а затем нажать на «Далее».
  6. Ввести имя проекта. Пример – WhatIsYourName.
  7. Выбрать в долгосрочной поддержке .Net 6.0. Обычно это происходит автоматически. Если нет – кликнуть по подходящему варианту вручную.

Как только все готово, можно нажать на «Создать». Через несколько секунд пользователь увидит на экране готовую форму. Остальные действия предстоит выполнять в ее пределах.

Запуск

После выбора подходящего шаблона и установки имени для него произойдет создание файла Program.vb. Имеющийся код изначально осуществляет вызов метода WriteLine. Он позволяет отобразить литеральную строчку «Привет, Мир!» в консольном окошке.

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

Запуск в отладке

Для этого необходимо:

  1. Нажать на кнопку WhatIsYourName в среде. Можно просто кликнуть по клавише F5.
  2. На экране появится консоль с соответствующей надписью. Это – режим отладки.
  3. Чтобы закрыть окно и вернуть в «прежнее состояние», потребуется нажать на любую клавишу.

Данный подход хорош для непосредственной проверки готовой утилиты или ее частей.

Автономный режим

А этот метод позволяет запускать программное обеспечение за пределами «Студии». Для этого потребуется сформировать самостоятельный контент с исполняемым файлом:

  1. Перейти в меню «Сборка».
  2. Кликнуть по надписи «Собрать решение».
  3. Выбрать ПКМ WhatIsYourName, а затем «Открыть в проводнике».
  4. Перейти к каталогу binDebugnet5.0.
  5. Запустить WhatIsYourName.exe.

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

Код для указания запроса

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

  1. Ввести код после Sub Main и перед End Sub. В ходе операции требуется заменить WriteLine.
  2. Нажать на кнопку WhatIsYourName или на F5 на клавиатуре. Это поможет собрать утилиту.
  3. Ввести запрошенные данные. В рассматриваемой ситуации – имя.
  4. Щелкнуть по любой кнопке на клавиатуре.

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

Система управления с GIT

GIT – система управления контроля версий. Является одной из самых популярных. Можно связать получившийся контент с Git. У VStudio имеются встроенные инструменты для проведения операции.

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

  1. В строчке состояния в правом нижнем углу «Студии» щелкнуть по «Добавить в систему управления версиями».
  2. Щелкнуть по GIT.
  3. Войти в GitHub. Это потребуется проделать в окне «Создать репозиторий…». Имя будет присвоено автоматически. Репозиторий по умолчанию является частным.
  4. Нажать на кнопку «Создать и отправить».

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

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

Очистка

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

Перейти в «Обозреватель решений».

  1. ПКМ нажать по интересующему проекту. Откроется его контекстное меню. В нем нужно выбрать «Открыть в проводнике».
  2. Закрыть «Студию».
  3. Перейти на два уровня папок вверх. Делается это непосредственно в «Проводнике».
  4. Нажать ПКМ по имени имеющегося проекта и скомандовать «Удалить».

Basic программа стерта с устройства. Теперь можно начать полноценную разработку нового софта.

Интересные примеры

Далее будут приведены довольно интересные примеры контента на рассмотренном ЯП. Это – готовые решения для выполнения тех или иных задач:

  1. Форма входа с подтверждением. Не совсем полноценное приложение. Больше отражает функцию. В меню проекта нужно разметить на экране кнопку, а ей присвоить следующую запись:
  2. Пароль для запуска ПО. Полезная возможность, особенно если хочется обеспечить дополнительную защиту или скрыть приложение от посторонних глаз. Запись осуществляется в стандартном проекте: . Здесь «12345» — это пароль. Его можно задать по собственному усмотрению.
  3. Вывод сообщения. Элементарная возможность:
  4. Рисование. Это – своеобразный графический мини-редактор. Рисовать клиент сможет прямо в открывающейся форме. В стандартном проекте предстоит указать следующее:.Цвета меняются при помощи значения QBColor(0), где 0 – это любая другая желаемая цифра.
  5. Запуск только один раз. Если попытаться активировать соответствующий контент повторно, система выдаст специальное сообщение: .
  6. Перезагрузка устройства. Рекомендуется размещать запись «на кнопке»: .

А еще можно посмотреть, сколько работает устройство. Основан предложенный пример на библиотеке kernel32. За счет этого сначала необходимо подключить DLL-библиотеку:

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

Изучение с нуля

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

Чтобы быстрее добиться успеха «с нуля», рекомендуется обратить внимание на дистанционные онлайн курсы. Пример – от образовательного центра OTUS. Там есть программы, благодаря которым в сжатые сроки можно освоить любую инновационную IT-профессию.

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

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

Хотите освоить современную IT-специальность? Огромный выбор курсов по востребованным IT-направлениям есть в Otus!

Источник

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

Программа
Оператор присваивания
Вычисления
Запуск программы
Работа со строками
Последовательность выполнения операторов
Логический тип
Сравнение строк

Программа

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

Программа на любом языке выглядит как обычный текст. В таком виде она может быть напечатана на бумаге. В таком же виде вы можете увидеть ее на экране компьютера. Для выполнения программа передается компьютеру, оснащенному специальной бейсик-средой. Конкретные варианты бейсик-среды мы будем обсуждать позже. Пока же программа для нас это просто некоторый текст, а бейсик-среда, которая, собственно, и может выполнять программу, – это просто бейсик. Таким образом, вы можете спросить приятеля: «А у тебя установлен бейсик?». А приятель может вам пожаловаться: «Бейсик выполнил мою программу до 120-й строки и остановился.»

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

Beep

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

' Это комментарий
Rem Это тоже комментарий
Beep ' А это комментарий, расположенный после оператора

Оператор присваивания

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

A = 5

Этот оператор присваивает переменной с именем A значение 5. Оператор

B = A

берет значение из переменной A и присваивает его другой переменной B.

A = 7.5

Теперь переменной A присвоено новое значение. Прежнее значение переменной безвозвратно утеряно, поскольку переменная может хранить только одно значение. Обратите внимание на то, что при записи числа 7,5 мы отделили целую часть от дробной не запятой, а точкой. Это стандартный способ записи десятичных дробных чисел во всех языках программирования.

A_Plus_B = A + B

Теперь у нас появилась переменная с именем A_Plus_B.
Имя переменной может состоять из нескольких символов. Оно всегда начинается с буквы и может включать в себя буквы, цифры и символы подчеркивания. Таким образом, можно использовать такое имя, которое напоминает читателю программы о назначении переменной. Здесь, однако, программист может сделать очень распространенную ошибку. Дело в том, что некоторые имена в бейсике уже заняты и их использование в качестве имен переменных приведет к ошибке. При этом бейсик выдаст сообщение об ошибке, совершенно непонятное для программиста. Пусть, к примеру, программист назвал свою переменную Beep. Он и понятия не имел о команде Beep. Бейсик же пытается помочь программисту с использованием именно этой команды, чем окончательно ставит программиста в тупик. Бейсик не различает в именах регистр букв, так что A_Plus_B и a_pluS_b – это просто разные написания одной и той же переменной. Конечно же, использовать разные написания следует, только если вы хотите затруднить чтение и понимание своей программы.

Тем временем у нас значение переменной A_Plus_B стало равным 12.5. Это бейсик сложил значения переменных A и B. Бейсик, оказывается, умеет еще и складывать.

A = 8

Значение переменной A опять изменилось, но это не вызвало изменения значения переменой A_Plus_B, несмотря на ее имя. Если мы однажды написали «A_Plus_B = A + B», это вовсе не означает что всегда будет выполняться равенство A_Plus_B = A + B. И вообще, оператор присваивания нельзя рассматривать как равенство. Иногда он действительно похож на равенство. Но вот другой пример: если мы хотим увеличить значение переменной A на единицу мы можем написать оператор

A = A + 1

Естественно, такой оператор нельзя рассматривать как равенство A = A + 1, ведь такое равенство никогда бы не выполнялось.

Итак, оператор присваивания предписывает вычислить выражение, которое находится справа от знака «=» и присвоить результат переменной, имя которой стоит слева от этого знака.

Вычисления

Как мы видим, справа от знака присваивания должно стоять выражение, которое бейсик должен вычислить. При помощи выражения программист указывает, какие вычисления и в какой последовательности должен произвести компьютер. В качестве выражения может выступать одиночная переменная или константа. Но выражение может быть произвольной сложности. В выражение могут входить числовые константы, переменные и знаки операций. Знаки операций и их старшинство в бейсике такие же, как и в математике, за исключением того, что для умножения используется знак «*», а для возведения в степень знак «^». Для указания порядка выполнения операций можно использовать круглые скобки. Имеется большой выбор стандартных математических функций. Например, Sqr – это извлечение квадратного корня, Sin – это взятие синуса.

Допустим, нам нужно вычислить длину гипотенузы c, при заданных длинах катетов 3 и 4. Мы можем выполнить следующие операторы:

a = 3
b = 4
c = Sqr(a ^ 2 + b ^ 2)

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

c = Sqr(3 ^ 2 + 4 ^ 2)

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

u = Atn(a / b)

Угол мы получили в радианах. Для перевода его в градусы нужно разделить его на пи и умножить на 180

u = u / 3.14159 * 180

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

pi = Atn(1) * 4
u = u / pi * 180

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

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

Запуск программы

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

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

Сохраните набранный текст на рабочий стол с расширением vbs. Операционная система знает, что файлы vbs содержат сценарий на одном из вариантов бейсика – языке VBScript, и показывает эти файлы в виде иконки, похожей на свиток. Теперь, если вы кликните на иконке (клик должен быть двойным или одинарным в зависимости от установок Windows), то ваша программа запустится. Язык VBScript – это упрощенный вариант бейсика. Например, команда Beep в этом языке отсутствует и, поэтому, работать не будет. Мы постараемся в дальнейшем не выходить за рамки языка VBScript, чтобы все примеры можно было запустить без особых хлопот.

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

s = InputBox ("Введите значение")
MsgBox s

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

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

Работа со строками

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

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

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

a_plus_b = "ABCDE"

присваивает переменной a_plus_b соответствующее строковое значение. Справа от знака присваивания «=» мы видим строковую константу. Строковая константа получается, если последовательность некоторых символов заключить в двойные кавычки. Двойные кавычки служат для бейсика признаком и ограничителем строковой константы, но не включаются в значение константы. Чтобы получить значение строковой константы, следует отбросить ограничивающие её кавычки. Таким образом, в нашем случае переменная a_plus_b получит строковое значение, состоящее из пяти символов ABCDE. Символы, которые находятся внутри кавычек, бейсик старается не анализировать. К примеру, если внутри строки встретится символ апострофа «‘», то остаток программной строки не будет рассматриваться бейсиком как комментарий. Однако бейсику, конечно, приходится при анализе внутренности строки реагировать на символ двойной кавычки, ведь этот символ по идее должен служить признаком окончания строки. Для того чтобы символ двойной кавычки всё же мог являться частью строки, в бейсике договорились удваивать этот символ, если он содержится в строковой константе. Например, константа “””A””” содержит три символа, а именно: “A”. Одинарная кавычка – апостроф – не удваивается. Например, мы можем записать такую константу: “can’t”. В отличие от написания имен, при написании текстовых констант приходится обращать внимание на регистр букв, поскольку “ABCDE” и “Abcde” – это разные константы.

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

Но продолжим обсуждение строкового типа. Основная, и пожалуй, единственная операция над текстовыми значениями – это сцепление текстов или конкатенация. Все остальные действия над строками осуществляются при помощи стандартных функций. Для конкатенации рекоменднуется использовать знак «&», хотя чаще всего можно вместо него пользоваться знаком «+». Разберем ряд примеров.

a = "ABC" & "DEF"
b = "ABC" + "DEF"

В данном случае обе переменные a и b получают одно и то же значение «ABCDEF». Нюансы возникают, когда в операции участвуют числа. Вот что будет при выполнении следующих операторов:

a = "111" & 222 ' результат "111222"
b = 111 & 222 ' результат "111222"
c = "111" + 222 ' результат 333
d = "AAA" + 222 ' ошибочный оператор

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

Теперь рассмотрим некоторые нюансы, связанные с преобразованием данных. Дело в том, что преобразование числа в строку и обратно происходит в соответствии с локальными установками Windows. Эти установки в частности конкретизируют символ, который используется при отделении дробной части числа от целой. На большинстве компьютеров этот символ – запятая. Бейсик же предполагает, что программу пишет программист, приверженный общемировым программистским ценностям, и изображающий число в программе с использованием точки. А вот, преобразуя число в строку, бейсик предполагает, что результат такого преобразования будет читать обычный бухгалтер, и здесь вполне оправдано применить локальные установки. Надо сказать, что не каждый программист подозревает о такой услужливости бейсика. Чтобы не попадать в таких случаях впросак, подробно разберем следующий пример:

a = "111" & 2.22 ' результат "1112,22"
b = 1.11 & 2.22 ' результат "1,112,22"
c = "1,11" + 2.22 ' результат 3.33
d = "1.11" + 2.22 ' ошибочный оператор

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

Рассмотрим теперь строковые функции.

Функция Len(str) возвращает длину строки str. Если строка пустая, то есть не содержит ни одного символа, то возвращается ноль.

Функция Left(str, count) принимает два параметра: строковый str и числовой count. Она отсчитывает с левой стороны строки str ровно count символов, формирует из них строку и возвращает ее значение. Если строка str содержит менее чем count символов, то возвращается вся строка str.

Функция Right(str, count) работает также как и функция Left, только отсчет идет с правой стороны строки.

Функция Mid(str, position, count) возвращает «середину» строки str, начиная с позиции position (нумерация символов строки ведется с единицы) и длиной count. Если параметр count не задан (то есть указано только два первых параметра), то возвращается часть строки начиная со стартовой позиции и до конца строки. Строка str может оказаться недостаточно длинной. В этом случае функция ведет себя довольно логично. Если указанная начальная позиция больше чем длина строки, то будет возвращена пустая строка. Если параметр count требует выхода за пределы исходной строки, то возвращаются те символы, которые имеются в наличии, то есть с начальной позиции position и до конца строки. Кстати, Mid – это сокращение от Middle – середина.

Приведем несколько примеров работы этих функций.

s = "12345678"
s1 = Left(s, 3) ' "123"
s2 = Left(s, 10) ' "12345678"
s3 = Left(s, 0) ' ""
s4 = Left(s, -1) ' Произойдет ошибка при выполнении
s5 = Right(s, 4) ' "5678"
s6 = Mid(s, 5, 2) ' "56"
s7 = Mid(s, 5) ' "5678"
s8 = Right(s, Len(s) - 4) ' "5678"

В бейсике имеются функции для поиска в строке. В качестве результата поиска эти функции возвращают позицию найденного фрагмента. Одна из этих функций функция InStr(start, str, pattern) ищет в строке str строку pattern и возвращает позицию найденного вхождения. Если вхождение не найдено, то возвращается 0. Направление поиска – слева направо. Если задан параметр start, то поиск осуществляется начиная с позиции start, иначе поиск ведется с начала строки.
Пример: пусть у нас имеется строка вида

s = "содержание1 <!-- комментарий --> содержание2"

в которой комментарий заключен в своеобразные многосимвольные скобки <!— —>. (Так принято в языке HTML-разметки.) Определить, где находится комментарий можно операторами

pos1 = InStr(s, "<!--") ' ищем начало комментария
pos2 = InStr(pos1, s, "-->") ' ищем конец комментария

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

cont = Left(s, pos1 - 1) & Mid(s, pos2 + 3)
comm = Mid(s, pos1 + 4, pos2 - pos1 - 4)

Мы пока не рассматриваем случай, когда комментария в строке s на самом деле нет.
Другая функция поиска InStrRev(str, pattern, start), так же как и функция InStr, ищет в строке подстроку, начиная с позиции start. Только поиск происходит в обратном направлении – от конца строки к ее началу. Если параметр start опущен, то поиск начинается с конца строки. Другой способ задать поиск с конца строки это задать параметр start равным -1. Обратите внимание, что в отличие от функции InStr для обратного поиска параметр start задается не в начале, а в конце списка параметров.

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

p = "C:Program FilesVB_6.0uninstall.exe"

применяем обратный поиск

pos1 = InStrRev(p, "")
' выделяем имя файла "uninstall.exe"
fnm = Mid(p, pos1 + 1)
pos2 = InStrRev(fnm, ".")
' выделяем расширение, включая точку
ext = Mid(fnm, pos2)

Замену подстроки в строке проще всего осуществлять функцией, которая так и называется – Replace (заменить). Эта функция не просто заменяет, она ищет и заменяет найденное. Например, строку

s = "Не имей сто рублей, а имей сто друзей."

после скачка цен можно «индексировать» так

t = Replace(s, "сто", "сто двадцать")

Теперь строка t будет иметь следующее значение:

"Не имей сто двадцать рублей, а имей сто двадцать друзей."

Функция нашла все вхождения подстроки «сто» и заменила их на строку «сто двадцать». Саму строку s функция оставила нетронутой. Так же как и функция InStr функция Replace может осуществлять поиск не с начала строки, а с указанного места. Позицию начала поиска можно указать в 4-м параметре. Единственное неудобство это то, что возвращаемое значение будет при этом начинаться с этого же места, то есть начало строки будет обрезано. Например:

t = Replace("12345678", "5", "*", 3) ' возвращается "34*678"

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

t = Replace(s, "сто", "сто двадцать", 1, 1)

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

"Не имей сто двадцать рублей, а имей сто друзей."

Если пятый параметр не задан или равен -1, то заменяются все вхождения, сколько бы их ни было найдено. Еще пара примеров. Следующий оператор удалит все пробелы из строки s:

s = Replace(s, " ", "")

а следующий оператор удалит пробел в конце строки, если он есть:

p = Left(p, Len(p) - 1) & Replace(Right(p, 1), " ", "")

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

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

If условие Then
    ... ' здесь расположена
    ... ' група операторов
End If

Как вы видите, это не совсем оператор, а какая-то непонятная конструкция, расположенная на нескольких строках. Первую строку этой конструкции и занимает, собственно, оператор If. Этот оператор открывает собой группу операторов. Признаком конца этой группы служит строка «End If». Операторы группы выполняются только в том случае, если условие оператора If истинно. В противном случае бейсик пропускает эти операторы и переходит к выполнению того, что следует за строкой «End If». В качестве условия должно выступать, выражение, истинность которого бейсик может проверить.

Например, нам надо вычислить максимум из значений переменных a и b. Сначала мы пробовали написать что-то вроде c = Max(a, b), но обнаружили, что функция Max среди стандартных функций бейсика отсутствует. Следующие операторы решили проблему

c = a
If a < b Then
    c = b
End If

Здесь в качестве условия выступает сравнение «a < b», смысл которого понятен из написания. Вычисление максимума можно записать по-другому:

If a < b Then
    c = b
Else
    c = a
End If

Здесь в составе условного оператора появилась еще одна группа, тоже состоящая из единственного оператора. Эта группа начинается после строки «Else». Слово else означает «иначе», «в противном случае». Операторы, следующие после «Else» выполняются только в том случае, если условие «a < b» не выполняется.
Сравнивать можно не только числа, но и строки. Здесь возникает много нюансов и мы в свое время будем о них говорить. Следующий условный оператор удаляет пробел в конце строки, если строка кончается пробелом:

If Right(p, 1) = " " Then
    p = Left(p, Len(p) - 1)
End If

Рассмотрим еще один пример: переменная s должна получить значение -1, если a < 0, значение 0, если a = 0, и значение 1, если a > 0. Мы можем записать следующую конструкцию:

If a < 0 Then
    s = -1
Else
    If a = 0 Then
        s = 0
    Else
        s = 1
    End If
End If

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

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

If a < 0 Then s = -1 ElseIf a = 0 Then s = 0 Else s = 1

Как видите, запись сократилась еще и за счет того, что пропали операторы End If. Отсутствие оператора End If, как вы знаете, чревато некоторыми недоразумениями. Например, в следующем варианте того же самого примера два слова If, но одно слово Else:

s = 1
If a <= 0 Then If a < 0 Then s = -1 Else s = 0

Непонятно, к которому из двух слов If бейсик отнесет слово Else. Эта двусмысленность решается стандартным образом: встретив слово Else, бейсик просматривает строку влево до первого If, который не имеет своего Else.

Вы можете подумать, что однострочный If можно применять только с такими группами операторов, которые состоят из одиночного оператора. Это не так. Группа может состоять из нескольких операторов, только между ними нужно поставить разделитель «:». Допустим, вам надо обменять значения переменных a и b, если а>b, тогда можно выполнить следующий оператор:

If a > b Then t = a : a = b : b = t

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

If a < 0 Then : s = -1 : Else : If a = 0 Then : s = 0 : Else : _
s = 1 : End If : End If

Ясно, что слова End If при этом пропускать нельзя. Можно ли при этом говорить о наглядности? Ответ на этот вопрос зависит от того, что вам нужно. Если вам нужна обозримая программа, которая помещается на одном экране, то за наглядность ее деталей наверно можно и не бороться.

Вернемся, однако к первоначальной записи нашего примера. Она ведь тоже не очень наглядна. Понятно, что вложенность операторов If не отражает сути дела, а вызвана только тем, что мы пытаемся выбирать из трех вариантов при помощи двухальтернативного If. Однако ведь у оператора If есть в распоряжении не только Else. Можно ведь использвать еще и ElseIf. Вот как будет выглядеть наш If, если его «разлить на троих».

If a < 0 Then
    s = -1
ElseIf a = 0 Then
    s = 0
Else
    s = 1
End If

Здесь внутри одного и того же оператора If уже три группы операторов. Вторая из них начинается со строки «ElseIf». А выполнение такого оператора происходит следующим образом: проверяется условие в строке «If» и если оно истинно, выполняется первая группа операторов. Если же это условие ложно, то проверяется условие в строке «ElseIf». При истинности этого условия выбор делается в пользу второй группы. Группа операторов после строки «Else» выполняется только в том случае, если оба условия ложны.

Оператор If может содержать несколько строк «ElseIf», каждая со своим условием и группой операторов. Бейсик будет проверять условия последовательно сверху вниз, пока не натолкнется на истинное. Группа с истинным условием и будет выполняться. Если все условия ложны то выполнится группа «Else». Если же «Else» отсутствует, а такое тоже возможно, то не будет выполнена ни одна из групп. После выполнения операторов любой из групп бейсик переходит к операторам, следующим непосредственно за строкой «End If», таким образом, различные группы операторов взаимоисключают друг друга.

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

Select Case a
Case 0
    s = "Ноль"
    t = "Никого"
Case 1, 2
    s = "Один или два"
    t = "Нормально"
Case Else
    s = "Больше двух"
    t = "Многовато будет"
End Select

Разберем подробнее этот оператор. Строки «Select Case» и «End Select» ограничивают начало и конец оператора. Внутри оператора имеются несколько строк «Case», которые разбивают содержимое оператора Case на группы операторов. Здесь так же как и в операторе If, бейсик может выполнить только одну группу операторов или не выполнить ни одной. Выполнение оператора начинается с вычисления контрольного выражения, которое стоит после слов «Select Case». В нашем случае это будет просто значение переменной a. Далее бейсик перебирает строки «Case» и проверяет, не равно ли контрольное выражение одному из выражений, которые перечислены после слова «Case». Первое же совпавшее выражение приводит к выполнению соответствующей группы операторов. Если ни одно из выражений не совпало, то выполняется группа, стоящая после строки «Case Else». Если же такой строки нет, то бейсик переходит к операторам, стоящим после «End Select», так и не выполнив ни одной группы.
Другой пример. Оператор анализирует первую букву строки s и присваивает переменной p значение «З», если эта буква звонкая и значение «Г», если эта буква глухая. Если первая буква строки не является согласной русской буквой, то оператор ничего не делает.

Select Case UCase(Left(s, 1))
Case "Б", "В", "Г", "Д", "Ж", "З", "Л", "М", "Н", "Р"
    p = "З"
Case "К", "П", "С", "Т", "Ф", "Х", "Ц", "Ч", "Ш", "Щ"
    p = "Г"
End Select

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

Вернемся к задаче выделения комментариев из строки вида

s = "содержание1 <!-- комментарий --> содержание2"

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

pos1 = InStr(s, "<!--")
If pos1 > 0 Then
    pos2 = InStr(pos1, s, "-->")
    If Pos2 > 0 Then
        cont = Left(s, pos1 - 1) & Mid(s, pos2 + 3)
        comm = Mid(s, pos1 + 4, pos2 - pos1 - 4)
    Else
        cont = s
        comm = ""
    End If
Else
    cont = s
    comm = ""
End If

Здесь вас должно смутить то, что один и тот же фрагмент программы, повторяется дважды. Мы имеем ввиду два оператора после строки «Else». Когда это только два оператора, то об экономии можно было бы и не заботиться. Ну а если бы это был обширный фрагмент, да в добавок его было бы нужно модифицировать от запуска к запуску? Универсальный способ избежать дублирования кода – это вынос этого кода в подпрограмму, и мы обязательно научимся это делать. Но в нашем случае можно просто немного изменить логику сравнений:

pos1 = InStr(s, "<!--")
If pos1 > 0 Then
    pos2 = InStr(pos1, s, "-->")
End If
If pos1 > 0 And pos2 > 0 Then
    cont = Left(s, pos1 - 1) & Mid(s, pos2 + 3)
    comm = Mid(s, pos1 + 4, pos2 - pos1 - 4)
Else
    cont = s
    comm = ""
End If

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

Логический тип

На самом деле, после слова «If» или «ElseIf» может стоять произвольное выражение, которое бейсик попытается привести к логическому типу. Выражение логического типа может принимать два значения True – «истина» и False – «ложь». Сравнение – это как раз и есть выражение логического типа, точнее говоря, – выражение, которое при вычислении дает значение логического типа.

Имеется шесть операций сравнения:

  • = – «равно»,
  • <> – «не равно»,
  • > – «больше»,
  • < – «меньше»,
  • >= – «больше или равно»,
  • <= – «меньше или равно»,

Над значениями логического типа возможны математические действия – это так называемые логические связки:

  • Not – «не»
  • And – «и»
  • Or – «или»

Первая связка – не совсем связка, в том смысле, что она не связывает два выражения, как And и Or, а ставится перед некоторым выражением и делает из него отрицание, то есть из True делает False, из False – True. Эта связка аналогична операции смены знака в арифметике «–». Связки And и Or часто называют логическим умножением и логическим сложением. Старшинство этих операций соответствует их арифметическим аналогам – сначала Not, потом And, потом Or.

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

((2 * (A ^ 2)) > 6.2) Or ((c < (3 + (5 * A))) And (s <> " "))

Если же старшинство нескольких стоящих рядом операций одно и то же, то операции выполняются последовательно слева направо:

A * B / C * D

эквивалентно

(((A * B) / C) * D)

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

u = u / 3.14159 * 180

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

Оператор

A = B = C

присваивает переменной A значение True, если переменные B и C равны между собой, и False в противном случае. Теперь вместо оператора

If B = C Then

можно написать – не пугайтесь

If A Then

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

A = B = C = D

Он выполняется по общим правилам. Здесь операция сравнения «=» выполняется справа налево, т. е.:

A = ((B = C) = D)

Иными словами, переменной A присваивается значение True, когда B равно C, а D равно True, либо B не равно C, а D равно False. В противном случае переменной A присваивается значение False.
Теперь разберемся, как бейсик приводит к логическому типу числовые и строковые выражения. Правила здесь очень простые: ноль приводится к значению False, не ноль – к True. Строковое значение может быть приведено к логическому значению только если это строка «true» или строка «false», при этом регистр букв безразличен. Несколько иллюстрирующих примеров:

n = 5
s = "tRU"
If n Then ' условие удовлетворяется
If n - 5 Then ' условие не удовлетворяется
If s Then ' вызовет ошибку выполнения
If s + "e" Then ' условие удовлетворяется

Бейсик может произвести и обратное преобразование

s = "Begin" & trUE ' даст нам "BeginTrue"
s = 4 + trUE ' даст нам 3

Последний пример не очень понятен. Дело в том, что бейсик видит числовую операцию и пытается привести логическое выражение к числу. False он привел бы к нулю, а True приводит к минус единице. Почему именно к минус единице, можно понять если вспомнить, что минус единица в двоичном виде выглядит как «все единицы».

Если вы не поняли предыдущего предложения, то данный абзац можно пропустить. Логические операции Not, Or, And (и другие), примененные к числам, не вызывают преобразования этих чисел к логическому типу, а применяются к этим числам «побитово», то есть каждый бит числа рассматривается как логическое значение: 0 — False, 1 — True, а операция производится параллельно над всеми битами. 3 Or 5 дает нам 7, а (Not 0) + 5 дает 4. Скобки в последнем случае обязательны.

Сравнение строк

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

s = "F"
If s < "G" Then

Здесь придется напомнить вам о том, что каждый символ строки запоминается в компьютере в виде кода – небольшого целого числа от 0 до 255. А числа уже можно сравнивать. Символ «F» меньше символа «G» просто потому что код символа «F» меньше чем код символа «G». Мы не будем здесь приводить коды символов. Скажем лишь, что коды букв соответствуют их алфавитному порядку – чем дальше буква от начала алфавита, тем ее код больше. Код строчных букв больше кода прописных. Код русских букв больше кода латинских. Коды цифр меньше чем коды букв, коды служебных символов (пробел, запятая) еще меньше.

Существует функция Asc, которая позволяет по символу определить код этого символа, например Asc(«F») вернет нам 70, Asc(«G») – 71. Функция Asc применима также к строке, состоящей из нескольких символов. В этом случае она возвращает код первого символа, а остальные символы игнорирует. Таким образом, если вы хотите узнать код второго символа в строке s, вам придется написать что-то вроде Asc(Mid(s, 2, 1)). Если вы примените функцию Asc к пустой строке, то получите ошибку выполнения.

В бейсике имеется функция Chr, которая решает обратную задачу – по коду символа определяет сам символ, точнее возвращается строка, состоящая из одного этого символа. Например, оператор

s = Chr(70) & "-" & Chr(71)

присвоит строке s значение «F-G». Без функции Chr бывает трудно обойтись, когда требуется включить в строку символы, не имеющие графического представления, например, символ табуляции или перевода строки.

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

Такой способ сравнения называется лексикографическим. Его можно использовать, когда надо упорядочить некоторые слова, например фамилии, по алфавиту. Та фамилия, которая «меньше», должна стоять выше в списке. Затруднения возникают, когда некоторые фамилии набраны прописными буквами, ведь код прописной буквы всегда меньше кода строчной (для одного и того же языка). Например, строка «ИГНАТОВ» меньше, чем строка «Иванов», и поэтому при упорядочении будет претендовать на верхние места в списке. Это не совсем то, чего бы нам хотелось.

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

s = "ИГНАТОВ"
t = "Иванов"

тогда вместо

If s < t Then

нужно написать

If UCase(s) < UCase(t) Then

Еще одну возможность предоставляет нам функция StrComp. Функция StrComp(s, t) сравнивает две строки s и t и возвращает 1, если первая строка меньше второй; возвращает 0, если строки равны; и возвращает 1 если первая строка больше второй. Первые два параметра функции представляют собой сравниваемые строки. Но у функции может быть и третий параметр – тип сравнения. Если третий параметр не задан, то предполагается, что он равен 0, то есть сравнение происходит обычным образом – так называемое двоичное сравнение. Если третий параметр равен единице, то сравнение происходит без учета регистра, точнее говоря, происходит сравнение строк, преобразованных в верхний регистр – так называемое текстовое сравнение. Таким образом, в нашем случае возможен еще и такой вариант:

If StrComp(s, t, 1) = -1 Then

Оказывается, функции InStr, InStrRev, Replace, работа которых связана со сравнением строк, также допускают дополнительный параметр, задающий тип сравнения. Проще всего привести несколько примеров.

s ="XXpXXpXXPXXP"
p = "P"
n = InStr(4, s, p, 1)
' Текстовое сравнение начиная с позиции 4 возвращает 6.
n = InStr(1, s, p, 0)
' Двоичное сравнение начиная с позиции 1 возвращает 9.
n = InStr(s, p)
' Двоичное сравнение (тип сравнения не указан) возвращает 9.
n = InStr(1, s, "W")
' Двоичное сравнение возвращает 0 ("W" не найдено).
n = InstrRev(s, p, 10, 0)
' Двоичное сравнение начиная с позиции 10 возвращает 9.
n = InstrRev(s, p, -1, 1)
' Текстовое сравнение начиная с последней позиции
' возвращает 12.
n = InstrRev(s, p, 8)
' Двоичное сравнение (тип сравнения не указан) возвращает 0.
ss = Replace("XXpXXPXXp", "p", "Y")
' Двоичное сравнение, начиная с позиции 1
' возвращает "XXYXXPXXY".
ss = Replace("XXpXXPXXp", "p", "Y", 3, -1, 1)
' Текстовое сравнение, начиная с позиции 3
' возвращает "YXXYXXY".

Источник

Введите в синее поле этот исходный код (рисунок 1):

  1. ‘ Vyvod tekstovoy stroki
  2. PRINT “Hello, World!”

Рисунок 1 – Первая программа на языке Basic

Рисунок 1 – Первая программа на языке Basic

Нажмите клавишу F5, что бы запустить программу на выполнение (рисунок 2).

Рисунок 2 – Запуск программы на QB64

Рисунок 2 – Запуск программы на QB64

Любую команду в программе можно снабдить поясняющим текстом – комментарием, который начинается служебным словом REM или одинарной кавычкой (‘).

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

Например (рисунок 3):

  1. REM Tak pishetsya kommentariy
  2. ‘i eto tozhe kommentariy

Рисунок 3 – Комментарии в QBasic и QB64

Рисунок 3 – Комментарии в QBasic и QB64

Как уже говорилось выше, оператор REM может быть заменен апострофом (‘). Всё что после символа апостроф (‘) или ключевого слова REM – это комментарий.

Например:

REM комментарий к блоку программы
или
<команда> ‘ тоже комментарий к блоку программы

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

Примечание: Если комментарий, начинаемый апострофом, стоит в конце строки после исполняемых операторов, то перед апострофом двоеточие не ставится, а перед оператором REM ставится, например (рисунок 4):

  1. A = 0 ‘dvoetochie ne stavitsya
  2. B = 0: REM dvoetochie stavitsya

Рисунок 3 – Двоеточие и комментарии

Рисунок 4 – Двоеточие и комментарии

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

Рассмотрим понятие «команда».

Команда (или оператор) – это ключевое слово, которое понимает язык программирования.

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

Формат (синтаксис) оператора (или команды) PRINT:

PRINT выражение[{;|,] [выражение…]

Смысл команды PRINT – это вывод на экран текстовой строки или значения переменной.

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

Спасибо за прочтение этой статьи.

Прикрепленные файлы:

  • first_program.bas
  • comments.bas
  • comments_colon.bas
Источник

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