Русский перевод оригинальной брошюры Microsoft «Microsoft Small Basic. Знакомство с программированием». Также, рекомендуем прочитать статью «Введение в Small Basic. Дополнение».
1. Введение
Small Basic и программирование
Под словами программирование для компьютера понимается процесс создания программного обеспечения с использованием языков программирования. Подобно тому, как люди могут понимать английский, или испанский, или французский языки и разговаривать на них, компьютеры могут понимать программы, написанные на специальных языках. Эти языки и называются языками программирования. Изначально существовало всего несколько таких языков, которые были достаточно просты для изучения и понимания. Но по мере развития компьютеров и ПО языки программирования также начали быстро эволюционировать, попутно включая в себя более сложные понятия. В результате большинство современных языков программирования и их понятия довольно сложны для начинающих разработчиков. Сложность восприятия у многих отбивает желание изучить или хотя бы попытаться понять компьютерное программирование.
Язык программирования Small Basic предназначен для того, чтобы сделать обучение программированию предельно простым и доступным занятием для новичков, которое также может приносить удовольствие. Язык Small Basic разрабатывался с намерением снести барьер сложности и проложить дорогу в удивительный мир компьютерного программирования.
Среда разработки Small Basic
Начнем с краткого введения в среду разработки Small Basic. Запуская SmallBasic.exe в первый раз, Вы увидите окно, которое выглядит следующим образом.
Рисунок 1 – Среда разработки Small Basic
Так выглядит среда Small Basic, где мы будем писать и запускать программы Small Basic. Среда разделена на несколько четко различимых между собой частей.
В Редакторе, обозначаемом [1], мы будем писать программный код на языке Small Basic. Если вы откроете образец программы или ранее сохраненную программу, то она отобразится в этом редакторе. В нем вы можете изменять программу и сохранять её для дальнейшего использования.
Вы также можете открыть сразу несколько программ и работать более чем с одной программой одновременно. Каждая программа, в которой Вы работаете, будет отображаться в отдельном редакторе. Редактор — в нём отображается программа, над которой Вы работаете в данный момент, называется активным редактором.
Панель инструментов, обозначаемая [2], используется для исполнения команд либо в активном редакторе, либо в операционной среде. С разнообразием команд мы познакомимся в процессе изучения Small Basic.
Рабочая область, обозначаемая [3], — это часть, где располагаются все окна редакторов.
Наша первая программа
Теперь, когда Вы уже знакомы со средой Small Basic, мы можем перейти к следующему этапу и начать программирование в ней. Как уже было ранее отмечено, редактор – это поле, в котором мы пишем команды. Давайте посмотрим, что произойдет, если мы напечатаем следующую строку в редакторе.
TextWindow.WriteLine("Здравствуй, мир!")
Это наша первая программа на языке Small Basic. Если Вы напечатали все верно, то в окне редактора должно появиться то же самое, что Вы видите на Рисунке 2.
Рисунок 2 – Первая программа
Теперь, когда мы напечатали нашу первую программу, давайте запустим ее и посмотрим, что произойдет. Запустить программу можно либо нажав на значок «Запуск», который расположен на панели инструментов, либо используя «горячую клавишу» F5 на клавиатуре. Если Вы все сделали правильно, то в результате выполнения нашей программы должно появиться такое же окно, как Вы видите ниже.
Рисунок 3 – Вывод первой программы
Поздравляем! Вы только что написали и запустили первую программу Small Basic. Очень короткую и простую программу, которая, тем не менее, является важным этапом на пути к тому, чтобы стать настоящим компьютерным программистом! Перед тем, как перейти к написанию более серьезных программ, необходимо обратить внимание на еще одну деталь. Нам необходимо понять, что произошло — что именно мы приказали компьютеру сделать, и как он узнал, что ему нужно сделать именно это? Для того чтобы это понять, в следующей главе мы проанализируем программу, которую только что написали.
Пока Вы печатали свою первую программу, Вы наверняка заметили всплывающее окно с перечнем команд (Рисунок 4). Это Контекстное Меню помогает Вам набрать программу быстрее. Передвигаться по нему можно с помощью клавиш Стрелка Вверх / Стрелка Вниз. Выбрав необходимую Вам команду, нажмите на клавиатуре клавишу «Ввод» (Enter), чтобы вставить ее в программу.
Рисунок 4 – Контекстное меню
Сохранение программы
Если Вы хотите выйти из Small Basic и вернуться к работе над программой, которую только что напечатали, позже, Вы можете просто сохранить её. Сохранять программы время от времени – хорошая привычка, таким образом, Вы застрахованы от потери информации в случае внезапного отключения питания компьютера. Текущую программу можно сохранить либо нажав на значок “Сохранить” на панели инструментов, либо используя сочетание клавиш “Ctrl+S” (нажатие клавиши S при нажатой клавише Ctrl).
2. Анализ первой программы
Что такое компьютерная программа?
Программа – это набор команд для компьютера. Эти команды описывают компьютеру точную последовательность его действий, которые он всегда выполняет. Как и люди, компьютеры выполняют команды, только если они написаны на понятном им языке. Такие языки и называются языками программирования. Существует множество языков, которые понятны компьютеру, и Small Basic — один из них.
Представьте себе разговор между Вами и Вашим другом. Вы будете пользоваться словами, из которых складываются предложения, чтобы передавать друг другу информацию. Подобно этому, языки программирования содержат в себе разнообразные сочетания слов, которые складываются в предложения и передают информацию в компьютер. Поэтому программы – это, в сущности, строки текста (иногда всего несколько, а иногда тысячи строк), которые вместе представляют одинаковый смысл, как для программиста, так и для компьютера.
Существует множество различных языков, которые понятны компьютеру. Java, C++, Python, VB и т.п. являются мощными современными языками программирования, которые используются для разработки как простых, так и сложных программ системы ПО.
Программы Small Basic
Обычная программа Small Basic состоит из связки командных предложений. Каждая строка программы представляет собой предложение, и каждое предложение является командой для компьютера. Когда мы просим компьютер запустить программу Small Basic, он переходит к программе и считывает первое предложение. Понимая, что именно мы хотим, он выполняет нашу команду. Выполнив первую команду, он возвращается к программе, считывает вторую строку и выполняет следующую команду. Компьютер продолжает выполнять команды до тех пор, пока не дойдет до конца программы. Только тогда вся программа будет выполнена.
Вернемся к первой программе
Ниже приведена первая программа, которую мы только что набрали:
TextWindow.WriteLine("Здравствуй, мир!")
Это очень простая программа, которая состоит из одного предложения (одной строки). Это предложение приказывает компьютеру вывести строку текста «Здравствуй, мир!» в Текстовом Окне (Text Window).
Буквально компьютер понимает это предложение как команду:
Написать «Здравствуй, мир!«
Вы уже наверняка заметили, что команду как и предложение можно разбить на несколько более коротких элементов, так же как обычное предложение можно разбить на слова. В первом предложении можно выделить 3 отдельные части:
TextWindow
WriteLine
“Здравствуй, мир!”
Точка, скобки и кавычки являются знаками пунктуации, которые необходимо ставить в определенных местах предложения, чтобы компьютер понял, чего именно мы от него хотим.
Знаки пунктуации, такие как кавычки, пробелы и скобки, являются важным элементом в компьютерных программах. Изменив их расположение в предложении или их количество, можно изменить передаваемый смысл.
Вспомните черное окно, которое появилось, когда мы запускали нашу первую программу. Это окно черного цвета называется консолью MS Windows, которой соответствует объект языка Small Basic TextWindow
(Текстовое Окно). Именно в консоли отображаются текстовые результаты выполнения программы. Существует много таких объектов, доступных для использования в наших программах (TextWindow
(Консоль), GraphicWindow
(Графическое окно), Mouse
(Мышь) и т.п.). Мы можем выполнять различне операции с этими объектами. В нашей программе мы уже использовали операцию WriteLine
. Вы также наверняка заметили, что за командой WriteLine
следует текст "Здравствуй, мир!"
в кавычках. Этот текст выступает в роли данных для операции WriteLine
, который потом выводится пользователю на экран. Как мы уже сказали, это называется данными для выполнения операции. Для выполнения одних операций требуется некоторое количество таких данных, для выполнения других операций данных может и не потребоваться.
Наша вторая программа
Теперь, проанализировав и поняв нашу первую программу, давайте продолжим и разнообразим ее, добавив цвета.
TextWindow.ForegroundColor = "Yellow"
TextWindow.WriteLine("Здравствуй, мир!")
Рисунок 5 – Добавление цвета
После запуска программы, написанной выше, Вы заметите, что в результате выполнения программы в Текстовом Окне выводится та же самая фраза “Здравствуй, мир!”, но на этот раз она напечатана желтым цветом вместо серого, которым фраза выводилась раньше.
Рисунок 6 — Hello World желтым цветом
Обратите внимание на новое предложение, которое мы добавили в нашей программе. Там используется новое слово ForegroundColor
, значение которого мы приравняли к значению “Yellow”
(«Желтый»). Это означает, что мы присвоили “Yellow”
к ForegroundColor
. Теперь различие между операциями ForegroundColor
и WriteLine
заключается в том, что ForegroundColor
не потребовала ни ввода данных, ни скобок. Вместо этого, за операцией последовал символ равно и слово. Мы определяем операцию ForegroundColor
как Свойство Текстового Окна. Ниже приведен список значений, которые используются в свойстве ForegroundColor
. Попробуйте заменить “Yellow”
одним из них и посмотрите, что произойдет – не забудьте про кавычки, это обязательно при записи названий цветов.
"Black"
— Чёрный"Blue"
— Синий"Cyan"
— Голубой"Gray"
— Серый"Green"
— Зеленый"Magenta"
— Малиновый"Red"
— Красный"White"
— Белый"Yellow"
— Желтый"DarkBlue"
— ТемноСиний"DarkCyan"
— ТемноГолубой"DarkGray"
— ТемноСерый"DarkGreen"
— ТемноЗеленый"DarkMagenta"
— ТемноМалиновый"DarkRed"
— ТемноКрасный"DarkYellow"
— ТемноЖелтый
Кроме того, цвета текста и фона в консоли можно задавать числовыми значениями от 0 до 15. Подробнее об этом — здесь.
3. Использование переменных
Использование переменных в программе
Было бы неплохо, если наша программа напечатала бы “Здравствуйте” с последующим именем пользователя, вместо обобщающего выражения “Здравствуй, мир!”, не правда ли? Чтобы это сделать, нам сначала необходимо узнать имя пользователя, потом сохранить его где-нибудь, а потом вывести “Здравствуйте” с именем пользователя. Давайте посмотрим, как это можно сделать:
TextWindow.Write("Введите Ваше имя: ")
name = TextWindow.Read()
TextWindow.WriteLine("Здравствуй, " + name)
После того как Вы напечатаете и выполните описанную выше программу, Вы увидите следующий результат:
Рисунок 7 – Узнаем имя пользователя
И когда Вы введете свое имя и нажмете клавишу «Ввод» (Enter), Вы увидите следующее:
Рисунок 8 – Личное приветствие
Если вы еще раз запустите эту программу, то компьютер еще раз спросит у вас ваше имя. Вы можете вписать другое имя, и он напишет «Здравствуй» с другим именем.
Анализ программы
В программе, которую мы только что запускали, Ваше внимание могла привлечь следующая строка:
name = TextWindow.Read()
Read()
выглядит так же как и WriteLine()
, только без вводимых данных. Это операция приказывает компьютеру подождать, пока пользователь напечатает что-нибудь и нажмет клавишу «Ввод» (Enter). Как только пользователь нажимает клавишу «Ввод» (Enter), она принимает данные и возвращается к выполнению программы. Интересно то, что любые данные, введенные пользователем, будут храниться в переменной, которая обозначается как name
(имя). Переменная — это место, где Вы можете временно хранить значения и использовать их позднее. В строке, которую Вы видите выше, name
использовалась для хранения имени пользователя.
Следующая строка также интересна:
TextWindow.WriteLine("Hello " + name)
Это место, где мы используем значение, хранящееся в переменной name
. Мы берем значение из переменной name
, дополняем с ее помощью фразу “Здравствуйте, ” и выводим целиком в Текстовом Окне.
Write
так же как и WriteLine
– еще одна операция с текстовым окном. Операция Write
позволяет Вам писать что-нибудь в Консоли, но при этом в конце текста не будет выполнен перевод строки и следующий текст напечатается на той же строке.
Как только переменной присваивается значение, ее можно использовать неоднократно. Например, можно сделать следующее:
TextWindow.Write("Введите Ваше имя: ")
name = TextWindow.Read()
TextWindow.Write("Здравствуй, " + name + ". ")
TextWindow.WriteLine("Как дела, " + name + "?")
И Вы увидите следующий результат:
Рисунок 9 – Повторное использование переменной
Правила для имён переменных
Для имен переменных (и подпрограмм), которые Вы сами будете создавать и использовать в своих программах, существуют определённые правила, которые обязательно соблюдать:
- Имя переменной и подпрограммы должно состоять из букв (больших и маленьких), цифр и знака подчеркивания («_»)
- Большие и маленькие буквы в именах переменных и подпрограмм различаются
- Имя переменной и подпрограммы может содержать буквы любого языка, а не только латинские (английские)
- Имя переменной и подпрограммы должно начинаться с буквы или знака подчеркивания («_»)
- Имя переменной и подпрограммы не должно совпадать с ключевыми словами языка, именами объектов и их методов, свойств и событий
- Следите за тем, чтобы разные переменные имели различные имена
Примеры:
Dog
— правильное имя
Dog13
— правильное имя
Dog 13
— неправильное имя (присутствует пробел)
Dog_13
— правильное имя
The dog
— неправильное имя (присутствует пробел)
The_dog
— правильное имя
13dog
— неправильное имя (начинается с цифры)
_13dog
— правильное имя
папа
— правильное имя
TextWindow
— неправильное имя (совпадает с именем объекта языка Small Basic)
dog
и Dog
— это две разные переменные!
Игра с числами
Мы только что разобрались, как можно использовать переменную для хранения имени пользователя. В следующих нескольких программах мы рассмотрим принцип хранения и управления числами в переменных. Начнем с очень простой программы:
number1 = 10
number2 = 20
number3 = number1 + number2
TextWindow.WriteLine(number3)
В результате выполнения программы в окне появится следующее:
Рисунок 10 – Добавление двух чисел
Обратите внимание на то, что числа вводятся без кавычек. Для чисел кавычки не обязательны. Кавычки необходимы только при работе с текстом.
В первой строке программы вы присваиваете переменной number1
значение 10. А во второй строке Вы присваиваете переменной number2
значение 20. В третьей строке Вы складываете number1
и number2
и присваиваете результат переменной number3
. Таким образом, переменная number3
будет иметь значение 30. Именно это мы и вывели в Текстовом Окне.
Теперь давайте немного изменим программу и посмотрим на результат:
number1 = 10
number2 = 20
number3 = number1 * number2
TextWindow.WriteLine(number3)
Вышеуказанная программа перемножит переменные number1
и number2
и сохранит результат в переменной number3
. Внизу мы видим результат выполнения этой программы:
Рисунок 11 – Умножение двух чисел
Аналогично Вы можете вычитать или делить числа. Внизу пример вычитания:
number3 = number1 - number2
Символ для деления ‘/’. Программа будет выглядеть следующим образом:
number3 = number1 / number2
Результат выглядит так:
Рисунок 12 – Деление двух чисел
Обычный конвертор температуры
Для этой программы мы воспользуемся формулой, чтобы преобразовать температуру в градусах Фаренгейта в температуру, измеряющуюся в градусах Цельсия.
Для начала, нам необходимо узнать температуру тела пользователя в градусах Фаренгейта и сохранить результат в переменной. Существует специальная операция, которая позволяет считывать числовые данные пользователя, и называется она TextWindow.ReadNumber
.
TextWindow.Write("Введите температуру в градусах Фаренгейта: ")
fahr = TextWindow.ReadNumber()
Как только мы сохранили результат в градусах Фаренгейта в переменной, мы можем перевести их в градусы Цельсия следующим образом:
celsius = 5 * (fahr - 32) / 9
Скобки означают для компьютера, что вычисление fahr – 32
он должен произвести в первую очередь, а остальные вычисления произвести потом. Теперь нам только остается вывести результат на экран. Соединив все вместе, мы получим вот такую программу:
TextWindow.Write("Введите температуру в градусах Фаренгейта: ")
fahr = TextWindow.ReadNumber()
celsius = 5 * (fahr - 32) / 9
TextWindow.WriteLine("Температура в градусах Цельсия: " + celsius)
А результат этой программы будет выглядеть вот так:
Рисунок 13 – Преобразование температуры
4. Условия и ветвление
Вернемся на секунду к нашей первой программе. Не было бы это здорово, если бы вместо обобщающего Здравствуй, мир!, мы могли бы сказать С добрым утром, Мир!, или Добрый вечер, Мир!, в зависимости от времени дня? В нашей следующей программе мы заставим компьютер говорить С добрым утром, Мир!, если время до полудня; и Добрый вечер, Мир!, если стрелки часов показывают после полудня.
If (Clock.Hour < 12) Then
TextWindow.WriteLine("С добрым утром, Мир!, ")
EndIf
If (Clock.Hour >= 12) Then
TextWindow.WriteLine("Добрый вечер, Мир!")
EndIf
При запуске программы, в зависимости от времени дня, Вы увидите один из следующих результатов:
Рисунок 14 – С добрым утром, Мир
Рисунок 15 – Добрый вечер, Мир
Давайте проанализируем первые три строки программы. Вы уже, наверное, поняли, что эта строка говорит компьютеру напечатать “Good Morning World”, если Clock.Hour
(час) меньше 12. Слова If
, Then
и EndIf
являются ключевыми словами, которые понимаются компьютером при запуске программы. За словом If
всегда следует условие; в данном случае этим условием является (Clock.Hour < 12
). Не забудьте о том, что необходимо ставить скобки, иначе компьютер не поймет Ваших намерений. За условием следует слово Then
и операции, которые нужно выполнить. И уже за операциями следует слово EndIf
. Для компьютера это означает, что условное исполнение закончено.
В Small Basic Вы можете использовать объект Clock
для получения информации о текущей дате и времени. С его помощью Вы также можете узнать текущий День Недели, Месяц, Год, Час, Минуты, Секунды по отдельности.
Между ключевыми словами Then
и EndIf
можно ввести несколько операций и компьютер выполнит их все, если условие подходит для каждой из них. Например, можно написать что-нибудь вроде:
If (Clock.Hour < 12) Then
TextWindow.Write("Доброе утро!")
TextWindow.WriteLine("Как Вам понравился завтрак?")
EndIf
Ключевое слово Else
В программе, описанной в начале главы, Вы могли заметить, что второе условие практически дублирует первое. Значение условия Clock.Hour
могло оказаться и ниже и выше 12. Нам даже не пришлось проверять его еще раз. В подобных случаях мы можем сократить два утверждения if..then..endif
до одного с помощью использования нового ключевого слова else
.
Если написать ту же программу, но с использованием else
, то она будет выглядеть следующим образом:
If (Clock.Hour < 12) Then
TextWindow.WriteLine("С добрым утром, мир!)
Else
TextWindow.WriteLine("Добрый вечер, мир!")
EndIf
Результат выполнения обеих программ одинаковый, что является для нас очень важным уроком в компьютерном программировании:
Часто, в программировании одну и ту же вещь можно сделать по-разному. Иногда, использование одного способа несет в себе больше смысла, чем использование другого. Выбор остается за программистом. Чем больше программ Вы пишите и чем опытнее Вы становитесь, тем заметнее для Вас эти различия, а также их достоинства и недостатки.
Структурирование текста
В приведенных примерах видно, как структурируются предложения между словами If
, Else
и EndIf
. Такое структурирование необязательно. Компьютер и без них отлично поймет программу. Тем не менее, это помогает нам видеть и лучше понимать структуру программы. Именно поэтому обычно принято структурировать предложения между блоками.
Четное или нечетное
Теперь, когда мы достаточно знаем о предложении If..Then..Else..EndIf
, давайте составим программу, которая, при внесении в нее числа, скажет, четное оно или нечетное.
TextWindow.Write("Введите число: ")
num = TextWindow.ReadNumber()
remainder = Math.Remainder(num, 2)
If (remainder = 0) Then
TextWindow.WriteLine("Число – четное.")
Else
TextWindow.WriteLine("Число – нечетное.")
EndIf
По выполнении программы Вы увидите следующий результат:
Рисунок 16 – Четное или нечетное
В этой программе мы познакомились с очередной полезной операцией Math.Remainder
. И как Вы уже поняли, Math.Remainder
разделит первое число на второе и выдаст ответ с остатком.
Ветвление
Вспомните, во второй главе мы учили, что при выполнении программы компьютер обрабатывает каждое предложение поочередно, в порядке сверху вниз. Однако существует специальное предложение, которое приказывает компьютеру перескакивать от одного предложения к другому независимо от порядка. Давайте посмотрим на следующую программу.
i = 1
start:
TextWindow.WriteLine(i)
i = i + 1
If (i < 25) Then
Goto start
EndIf
Рисунок 17 – Использование ключевого слова Goto
В вышеописанной программе мы присвоили переменной i значение 1. Потом мы добавили предложение, которое заканчивается двоеточием (:)
start:
Это называется метка. Метки, как закладки, понятны компьютеру. Закладке можно присвоить любое имя и можно добавить столько меток в программу, сколько Вам захочется, только всем им нужно дать разные имена.
Вот еще одно любопытное командное предложение:
i = i + 1
Это предложение компьютер поймет как команду прибавить 1 к значению переменной i и присвоить ей же полученный результат. Поэтому, если значение переменной i до выполнения команды было равно 1, то после ее выполнения оно будет равно 2.
И наконец,
If (i < 25) Then
Goto start
EndIf
Эта часть программы воспринимается компьютером как команда к выполнению алгоритмических предложений заново с метки start, если значение переменной i меньше, чем число 25.
Бесконечное выполнение
Используя в программе предложение Goto, Вы можете заставить компьютер повторять выполнение какой-либо операции любое количество раз. Например, можно использовать программу Even or Odd и изменить ее так, как показано ниже; тогда программа будет выполняться бесконечно. Остановить выполнение программы можно нажатием на значок Закрыть (X) в верхнем правом углу окна.
begin:
TextWindow.Write("Введите число: ")
num = TextWindow.ReadNumber()
remainder = Math.Remainder(num, 2)
If (remainder = 0) Then
TextWindow.WriteLine("Число – четное.")
Else
TextWindow.WriteLine("Число – нечетное.")
EndIf
Goto begin
Рисунок 18 – Бесконечное выполнение операции
5. Циклы
Оператор цикла For
Давайте вернемся к программе, созданной в предыдущей главе.
i = 1
start:
TextWindow.WriteLine(i)
i = i + 1
If (i < 25) Then
Goto start
EndIf
Эта программа выводит на экран числа от 1 до 24. Процесс приращения величины к значению переменной широко применяется в программировании, а с помощью языков программирования можно сделать этот процесс проще. Вышеупомянутая программа равноценна следующей:
For i = 1 To 24
TextWindow.WriteLine(i)
EndFor
Результат будет выглядеть так:
Рисунок 19 – Применение цикла For
Обратите внимание на то, что мы сократили количество предложений в программе с 8 до 4, а результат выполнения остался таким же, как и у 8-строчной программы! Помните, в предыдущей главе мы говорили о том, что для одной и той же задачи можно найти несколько вариантов решения? Это отличный пример.
Операция For..EndFor
в программной терминологии называется циклом. С ее помощью можно работать с переменной, давая ей начальное и конечное значение, а компьютер прирастит переменную за вас. С каждым приращением переменной компьютер выполняет командные предложения между словами For
и EndFor
.
Если вы хотите, чтобы значение переменной увеличивалось на 2, а не на 1 – т.е. если вы хотите вывести на экран все нечетные числа между 1 и 24, то для выполнения этой операции Вы также можете воспользоваться циклом.
For i = 1 To 24 Step 2
TextWindow.WriteLine(i)
EndFor
Рисунок 20 – Только нечетные числа
Слово Step 2
, являющееся частью командного предложения For
, дает компьютеру команду прирастить значение переменной i
на 2
, вместо стандартной 1. Используя слово Step
(шаг), Вы можете задавать необходимое Вам значение приращения. Можно даже задать отрицательное значение шага и заставить компьютер делать вычисление в обратном порядке, как в нижеприведенном примере:
For i = 10 To 1 Step -1
TextWindow.WriteLine(i)
EndFor
Рисунок 21 – Вычисление в обратном порядке
Оператор цикла While
Оператор While является еще одним способом выполнения цикла. Такая операция очень пригодится в случае, если переменная счетчика цикла неизвестна заранее. В то время как операция For loop выполняется заданное количество раз, операция While
выполняется до тех пор, пока не выполнится заданное условие. В примере, который мы приведем ниже, мы делим число на два до тех пор, пока значение результата больше 1.
number = 100
While (number > 1)
TextWindow.WriteLine(number)
number = number / 2
EndWhile
Рисунок 22 – Цикл деления на два
В вышеприведенной программе мы присваиваем значение 100 числу и выполняем While
до тех пор, пока значение числа больше 1. Внутри цикла мы печатаем число, а потом делим его на 2. Как и предполагается, в результате выполнения программы на экран будут выводиться числа, которые поочередно будут делиться пополам.
Такую программу будет сложно написать, используя операцию For
, потому что мы не знаем, сколько раз должно будет выполниться условие во время выполнения цикла. А с помощью операции While
проверка условия и задание для компьютера продолжить или остановить выполнение цикла представляется простым.
Интересен тот факт, что каждая операция While
может быть развернута в командное предложение If..Then
. Например, вышеприведенная программа может быть написана следующим образом, не влияя на окончательный результат.
number = 100
startLabel:
TextWindow.WriteLine(number)
number = number / 2
If (number > 1) Then
Goto startLabel
EndIf
Фактически, компьютер для себя переводит каждую операцию While в командное предложение If..Then наряду с предложением Goto.
6. Первые шаги в графике
Во всех примерах, которые мы разбирали в предыдущих главах, мы пользовались Текстовым Окном, чтобы пояснить основы языка Small Basic. Однако в запасах у этого языка есть еще и мощный арсенал Графических возможностей, изучение которых мы начнем в этой главе.
Знакомство с Графическим Окном
Точно так же как в Текстовом Окне мы работали с Текстом и Числами, Small Basic предоставляет нам возможность работать с Графическим Окном (GraphicsWindow
), в котором можно рисовать разнообразные вещи. Давайте начнем с визуализации Графического Окна.
GraphicsWindow.Show()
Выполнив эту программу, Вы увидите, что вместо привычного черного текстового окна появилось белое Окно, похожее на то, которое Вы видите ниже. В нем пока еще ничего не отображается. Это базовое окно, в котором мы начнем работу в этой главе. Закрыть это окно можно нажав на значок ‘X’ в верхнем правом углу.
Рисунок 23 – Пустое графическое окно
Установки графического окна
Вид Графического окна можно настроить по своему желанию. Можно изменить название, цвет фона и размер окна. Давайте продолжим и попробуем немного изменить окно, чтобы поближе познакомится с его возможностями.
GraphicsWindow.BackgroundColor = "SteelBlue"
GraphicsWindow.Title = "Мое графическое окно"
GraphicsWindow.Width = 320
GraphicsWindow.Height = 200
GraphicsWindow.Show()
Ниже Вы можете видеть, как изменилось окно. Цвет фона можно изменить, выбрав один из представленных в Приложении B. Попробуйте задать окну разные свойства, чтобы посмотреть, как изменится его вид.
Рисунок 24 — Настроенное графическое окно
Рисование линий
В Графическом Окне мы можем рисовать различные фигуры, текст и даже картинки. Начнем с рисования простых фигур. Ниже приведена программа, которая нарисует пару линий в Графическом Окне.
GraphicsWindow.Width = 200
GraphicsWindow.Height = 200
GraphicsWindow.DrawLine(10, 10, 100, 100)
GraphicsWindow.DrawLine(10, 100, 100, 10)
Рисунок 25 – Крест-накрест
Вместо названий цветов Вы можете использовать систему символов для их обозначения (#RRGGBB). Например, #FF0000 означает Red (красный), #FFFF00 – Yellow (желтый), и т.д. Более подробную информацию о цвете можно будет узнать в пункте.
Первые две строки программы настраивают окно, а последующие две строки рисуют перекрещенные линии. Первые два числа, следующие за командой DrawLine
, задают начальные координаты осей x и y, а другие два числа определяют конечные координаты осей x и y. Интересно отметить то, что в компьютерной графике оси координат (0, 0) начинаются в верхнем левом углу окна. Фактически, в пространственной системе координат считается, что окно находится во 2-м квадранте.
Рисунок 26 – Карта системы координат
Возвращаясь к программе, в которой мы рисовали линии, интересно отметить, что в Small Basic можно изменять свойства линии, такие как ее цвет и толщина. Сначала, давайте изменим цвет линий так, как показано в следующей программе.
GraphicsWindow.Width = 200
GraphicsWindow.Height = 200
GraphicsWindow.PenColor = "Green"
GraphicsWindow.DrawLine(10, 10, 100, 100)
GraphicsWindow.PenColor = "Gold"
GraphicsWindow.DrawLine(10, 100, 100, 10)
Рисунок 27 – Изменение цвета линии
А сейчас давайте изменим ее размер. В нижеприведенной программе мы изменяем толщину линии до 10 вместо 1, которая присваивается ей по умолчанию.
GraphicsWindow.Width = 200
GraphicsWindow.Height = 200
GraphicsWindow.PenWidth = 10
GraphicsWindow.PenColor = "Green"
GraphicsWindow.DrawLine(10, 10, 100, 100)
GraphicsWindow.PenColor = "Gold"
GraphicsWindow.DrawLine(10, 100, 100, 10)
Рисунок 28 – Толстые цветные линии
Используя команды PenWidth
(ширина карандаша) и PenColor
(цвет карандаша), мы можем изменить карандаш, с помощью которого рисуются линии. Этими командами можно изменить не только нарисованные линии, но и нарисованные фигуры уже после того, как все свойства изменены.
Используя те же циклические команды, о которых мы говорили в предыдущей главе, мы с легкостью можем написать программу, которая нарисует множество линий, постепенно увеличивающихся в толщине.
GraphicsWindow.BackgroundColor = "Black"
GraphicsWindow.Width = 200
GraphicsWindow.Height = 160
GraphicsWindow.PenColor = "Blue"
For i = 1 To 10
GraphicsWindow.PenWidth = i
GraphicsWindow.DrawLine(20, i * 15, 180, i * 15)
EndFor
Рисунок 29 –Линии карандаша разной ширины
Интересно в этой программе то, что мы можем увеличивать ширину карандаша циклически, т.е. с выполнением каждого цикла под старой линией рисуется новая.
Рисование и заливка фигур
Для рисования фигур обычно используются две операции. Это операции Draw
и Fill
. Используя операцию Draw
, контур фигуры можно нарисовать карандашом, а при использовании операции Fill
фигура рисуется кистью. Например, с помощью следующей программы мы нарисуем два прямоугольника, один – красным карандашом, а другой – зеленой кистью.
GraphicsWindow.Width = 400
GraphicsWindow.Height = 300
GraphicsWindow.PenColor = "Red"
GraphicsWindow.DrawRectangle(20, 20, 300, 60)
GraphicsWindow.BrushColor = "Green"
GraphicsWindow.FillRectangle(60, 100, 300, 60
Рисунок 30 – Рисование и заливка
Для рисования или заливки прямоугольника Вам понадобятся четыре числа. Первые два числа обозначают точки осей координат X и Y для верхнего левого угла прямоугольника. Третье число служит для обозначения ширины прямоугольника, а четвертое – для обозначения его высоты. Фактически, такая же схема может быть использована при рисовании и заливке эллипсов, как в нижеприведенной программе.
GraphicsWindow.Width = 400
GraphicsWindow.Height = 300
GraphicsWindow.PenColor = "Red"
GraphicsWindow.DrawEllipse(20, 20, 300, 60)
GraphicsWindow.BrushColor = "Green"
GraphicsWindow.FillEllipse(60, 100, 300, 60)
Рисунок 31 – Рисование и заливка эллипсов
В случае с кругами принцип написания программы остается тем же, что в случае с эллипсами. Если вы хотите нарисовать круги, Вам необходимо задать ширину и высоту.
GraphicsWindow.Width = 400
GraphicsWindow.Height = 300
GraphicsWindow.PenColor = "Red"
GraphicsWindow.DrawEllipse(20, 20, 100, 100)
GraphicsWindow.BrushColor = "Green"
GraphicsWindow.FillEllipse(100, 100, 100, 100)
Рисунок 32 – Круги
7. Занимательные фигуры
В этой главе мы позволим себе немного развлечься, используя всевозможные операции, с которыми мы уже успели познакомиться. Здесь мы приведем примеры того, как можно сочетать различные операции для создания интересных неординарных программ.
Множество прямоугольников
Здесь мы нарисуем множество прямоугольников, циклически увеличивающихся в размерах.
GraphicsWindow.BackgroundColor = "Black"
GraphicsWindow.PenColor = "LightBlue"
GraphicsWindow.Width = 200
GraphicsWindow.Height = 200
For i = 1 To 100 Step 5
GraphicsWindow.DrawRectangle(100 - i, 100 - i, i * 2, i * 2)
EndFor
Рисунок 33 — Множество прямоугольников
Множество кругов
Вариант предыдущей программы, рисующей круги вместо прямоугольников.
GraphicsWindow.BackgroundColor = "Black"
GraphicsWindow.PenColor = "LightGreen"
GraphicsWindow.Width = 200
GraphicsWindow.Height = 200
For i = 1 To 100 Step 5
GraphicsWindow.DrawEllipse(100 - i, 100 - i, i * 2, i * 2)
EndFor
Рисунок 34 – Множество кругов
Случайное расположение
В этой программе используется операция GraphicsWindow.GetRandomColor для произвольного выбора цвета кисти, а также операция Math.GetRandomNumber (получить случайное число) – для задания кругам координат точек. Эти две операции можно комбинировать по-разному для написания интересных программ, которые каждый раз будут выполняться с разным результатом.
GraphicsWindow.BackgroundColor = "Black"
For i = 1 To 1000
GraphicsWindow.BrushColor = GraphicsWindow.GetRandomColor()
x = Math.GetRandomNumber(640)
y = Math.GetRandomNumber(480)
GraphicsWindow.FillEllipse(x, y, 10, 10)
EndFor
Рисунок 35 – Расположение в случайном порядке
Фракталы
С помощью следующей программы можно нарисовать треугольный фрактал, используя случайные числа. Фрактал – это геометрическая фигура, определенная часть которой (родительский элемент) повторяется снова и снова, изменяясь в размерах. В данном случае программа рисует сотни треугольников, каждый из которых в точности похож на родительский элемент. Уже в течение первых нескольких секунд выполнения программы Вы увидите, как треугольники будут медленно формироваться из нескольких точек. Логику происходящего трудно описать, поэтому оставим это задание для Вашего понимания.
GraphicsWindow.BackgroundColor = «Black»
x = 100
y = 100
For i = 1 To 100000
r = Math.GetRandomNumber(3)
ux = 150
uy = 30
If (r = 1) then
ux = 30
uy = 1000
EndIf
If (r = 2) Then
ux = 1000
uy = 1000
EndIf
x = (x + ux) / 2
y = (y + uy) / 2
GraphicsWindow.SetPixel(x, y, "LightGreen")
EndFor
Рисунок 36 – Треугольный фрактал
Если Вы захотите увидеть сам процесс формирования фрактала из точек Вы можете прибегнуть к помощи операции Proram.Delay
, которая задержит выполнение цикла. В этой операции указывается число в миллисекундах, которое означает коэффициент задержки. Ниже Вы видите преобразованную программу с измененной строкой, выделенной жирным шрифтом.
GraphicsWindow.BackgroundColor = "Black"
x = 100
y = 100
For i = 1 To 100000
r = Math.GetRandomNumber(3)
ux = 150
uy = 30
If (r = 1) then
ux = 30
uy = 1000
EndIf
If (r = 2) Then
ux = 1000
uy = 1000
EndIf
x = (x + ux) / 2
y = (y + uy) / 2
GraphicsWindow.SetPixel(x, y, "LightGreen")
Program.Delay(2)
EndFor
Увеличение коэффициента задержки замедлит выполнение программы. Вы можете экспериментировать с цифрами, чтобы подобрать подходящую Вам длительность выполнения программы.
Эту программу можно также изменить, заменив в ней строку:
GraphicsWindow.SetPixel(x, y, "LightGreen")
на строки:
color = GraphicsWindow.GetRandomColor()
GraphicsWindow.SetPixel(x, y, color)
Это изменение в программе позволит нарисовать треугольник случайно выбираемыми цветами.
8. Черепашья графика
Logo (Лого)
В 1970е существовал один простой, но мощный язык программирования Logo (Лого), которым пользовались всего несколько ученых. Но через некоторое время кто-то добавил к функциям языка «Графику в относительных командах» и «Черепашку», которая была видна на экране и чьи движения соответствовали таким командам как Двигаться Вперед, Повернуть Направо, Повернуть Налево и т.д. С помощью Черепашки оказалось возможным рисование фигур разной интересной формы на экране. Благодаря этому язык стал более понятным для пользователей и привлек к себе интерес людей всех возрастов, и именно поэтому он приобрел такую бешеную популярность в 1980е.
В Small Basic есть такая же черепашка, способная выполнять многие функции, заложенные в программах Small Basic. В этой главе мы расскажем Вам как с помощью Черепашки вывести графические данные на экран.
Черепашка
Для начала сделаем так, чтобы Черепашка была видна на экране. Этого можно добиться однострочной программой.
Turtle.Show()
При запуске этой программы появится белое окно, такое же, как и в предыдущей главе, но только здесь в центре окна Вы увидите Черепашку. Это и есть та самая Черепашка, которая будет выполнять все наши команды и рисовать все, что мы захотим.
Рисунок 37 – Появление Черепашки
Перемещение и рисование
Одна из команд, понятных Черепашке – Move
(Перемещение). Выполнение данной операции требует ввода числа. Число сообщает Черепашке насколько далеко ей нужно продвинуться. В следующем примере мы заставим Черепашку продвинуться на 100 пикселей.
Turtle.Move(100)
После запуска этой программы Вы увидите, как Черепашка будет медленно продвигаться на 100 пикселей вверх. По мере ее продвижение Вы также заметите, что она оставляет линию после себя. После того как Черепашка остановится, результат будет выглядеть следующим образом.
Используя функции Черепашки необязательно включать её видимость с помощью операции Show()
. Черепашка автоматически появляется на экране при операциях с ней.
Рисунок 38 – Перемещение на сто пикселей
Рисуем квадрат
У квадрата имеется четыре стороны – две вертикальные и две горизонтальные. Чтобы нарисовать квадрат нам необходимо заставить Черепашку нарисовать линию, повернуть направо и нарисовать еще одну линию и продолжить эти действия до тех пор, пока не закончим рисовать четыре стороны. Такая программа будет выглядеть следующим образом.
Turtle.Move(100)
Turtle.TurnRight()
Turtle.Move(100)
Turtle.TurnRight()
Turtle.Move(100)
Turtle.TurnRight()
Turtle.Move(100)
Turtle.TurnRight()
При выполнении программы Вы увидите, как Черепашка рисует квадрат, линия за линией, и результат будет похож на фигуру, которую Вы видите ниже.
Рисунок 39 – Черепашка рисует квадрат
Интересно отметить, что мы выполняем две операции снова и снова – а именно четыре раза. Мы уже знаем, что такие повторяющиеся команды можно выполнять с помощью цикла. Итак, если мы возьмем и изменим эту программу так, чтобы она выполнялась с помощью цикла For..EndFor
, то внешний вид программы упроститься и будет выглядеть следующим образом.
For i = 1 To 4
Turtle.Move(100)
Turtle.TurnRight()
EndFor
Изменение цвета
Черепашка рисует фигуры в точно таком же Графическом Окне, какое мы видели в предыдущей главе. Это означает, что все операции, изученные в предыдущей главе, актуальны и здесь. Например, следующая программа нарисует квадрат со сторонами разных цветов.
For i = 1 To 4
GraphicsWindow.PenColor = GraphicsWindow.GetRandomColor()
Turtle.Move(100)
Turtle.TurnRight()
EndFor
Рисунок 40 – Изменение цвета
Более сложные фигуры
Черепашка, в дополнении к операциям TurnRight
(ПоворотНаправо) и TurnLeft
(ПоворотНалево), также выполняет операцию Turn
(Поворот). Для выполнения этой операции требуется передать данные, обозначающих угол поворота черепашки. С помощью этой операции можно нарисовать многоугольник с любым количеством сторон. Следующая программа нарисует шестиугольник.
For i = 1 To 6
Turtle.Move(100)
Turtle.Turn(60)
EndFor
Запустите эту программу и посмотрите, действительно ли в итоге получится шестиугольник. Заметьте, что если угол между сторонами равен 60 градусам, то мы применяем операцию Turn(60)
. Для многоугольника, чьи стороны равны, можно легко узнать, чему равен угол между ними, разделив 360 на количество сторон. Пользуясь этой информацией и переменными, мы с легкостью можем написать стандартную программу, которая подойдет для рисования многоугольника с любым количеством сторон.
sides = 12
length = 400 / sides
angle = 360 / sides
For i = 1 To sides
Turtle.Move(length)
Turtle.Turn(angle)
EndFor
С помощью этой программы можно нарисовать любой многоугольник, всего лишь изменяя значение переменной sides
. Введя значение 4, в результате выполнения программы мы получим Квадрат, такой же получился вначале. Введя достаточно большое значение переменной, например 50, мы получим многоугольник, мало отличающийся по внешнему виду от круга.
Рисунок 41 – Рисуем многоугольник с 12 сторонами
Используя тот же принцип, что мы применили сейчас, можно заставить Черепашку нарисовать множество кругов, каждый с небольшим сдвигом. Результат получится интересным.
sides = 50
length = 400 / sides
angle = 360 / sides
Turtle.Speed = 9
For j = 1 To 20
For i = 1 To sides
Turtle.Move(length)
Turtle.Turn(angle)
EndFor
Turtle.Turn(18)
EndFor
В вышеприведенной программе используются два цикла For..EndFor
, один внутри другого. Внутренний цикл (i = 1 to sides
) похож на программу рисования многоугольника и отвечает за рисование круга. Внешний цикл (j = 1 to 20
) отвечает за поворот Черепашки после каждого нарисованного ею круга. Он также говорит Черепашке нарисовать 20 кругов. Соединив все вместе, результат выполнения этой программы получится очень интересным, а именно – мы получим вот такую фигуру.
В данной программе мы заставили Черепашку рисовать быстрее, увеличив скорость ее передвижения до 9. Это свойство можно менять, задавая значение скорости от 1 до 10, таким образом, заставляя Черепашку двигаться с той скоростью, с которой Вам хочется.
Рисунок 42 – Рисование кругов
Движение кругами
Можно заставить Черепашку перестать рисовать, применив операцию PenUp
. С ее помощью можно передвинуть Черепашку в любое место на экране, при этом не рисуя линию. Применив операцию PenDown
, Черепашка снова начнет рисовать. С помощью этих операций можно достигнуть интересного эффекта как, например, пунктирные линии. Подобные операции используются в следующей программе, чтобы нарисовать пунктирный многоугольник.
sides = 6
length = 400 / sides
angle = 360 / sides
For i = 1 To sides
For j = 1 To 6
Turtle.Move(length / 12)
Turtle.PenUp()
Turtle.Move(length / 12)
Turtle.PenDown()
EndFor
Turtle.Turn(angle)
EndFor
И снова, в этой программе два цикла. Внутренний цикл рисует разовую пунктирную линию, а внешний цикл определяет, сколько линий нужно нарисовать. В нашем примере переменной sides
было присвоено значение 6, и в результате мы получили шестиугольник с пунктирными линиями, как Вы можете видеть ниже.
Рисунок 43 – Использование PenUp и PenDown
9. Подпрограммы
Очень часто при написании программы можно столкнуться со случаями, когда приходится выполнять один и тот же набор шагов снова и снова. В таких случаях, скорее всего, нет смысла в написании одних и тех предложений несколько раз. Именно тогда на помощь и приходит Подпрограмма.
Подпрограмма – это часть компьютерной программы, содержащая описание определенного набора действий, и которая может быть вызвана из разных частей программы. Подпрограммы идентифицируются именем, которому предшествует ключевое слово Sub
, и в конце имеют ключевое слово EndSub
для выхода из подпрограммы. Например, следующий фрагмент представляет собой подпрограмму с именем PrintTime
, которая выводит в Текстовом Окне текущее время.
Sub PrintTime
TextWindow.WriteLine(Clock.Time)
EndSub
Внизу Вы видите программу, которая включает в себя подпрограмму и вызывает ее из разных частей программы.
' Это основная программа
PrintTime()
TextWindow.Write("Введите Ваше имя: ")
name = TextWindow.Read()
TextWindow.Write(name + ", сейчас: ")
PrintTime()
' Это подпрограмма
Sub PrintTime
TextWindow.WriteLine(Clock.Time)
EndSub
Рисунок 44 – Вызов обычной Подпрограммы
Вы вызываете подпрограмму командой SubroutineName()
(ИмяПодпрограммы()). Для вызова подпрограммы необходимо использовать скобки в конце имени подпрограммы: “()
”, чтобы компьютеру было понятно, что будет использована подпрограмма.
Преимущества подпрограмм
Запомните, что Вы можете вызвать только подпрограмму SmallBasic из той же самой программы. Вы не можете вызвать подпрограмму из другой программы.
Как Вы успели заметить, использование подпрограмм помогает нам уменьшить количество программного кода, вводимого для выполнения программы. Написав подпрограмму PrintTime
один раз, Вы сможете впоследствии обращаться к ней из любой части программы, и она будет выводить текущее время.
В дополнение, подпрограммы могут помочь в разборе сложных проблем на несколько маленьких частей. Если Вам необходимо, например, решить сложное уравнение, Вы можете написать несколько подпрограмм, которые решат небольшие части этого сложного уравнения. Потом Вы можете сложить результаты вместе для решения Вашей сложной задачи.
Подпрограммы также могут быть полезны для приведения программы в удобочитаемый вид. Другими словами, если у Вас есть удачно названные подпрограммы для основных частей Вашей программы, которыми вы часто пользуетесь, то программа становится легкой для чтения и понимания. Это очень важно, если Вы хотите понять чью-либо программу или если Вы хотите, чтобы Ваша программа была понятна другим. Иногда это бывает полезным даже тогда, когда Вы вдруг захотите прочитать свою же программу, например, через неделю после того, как написали ее.
Использование переменных
Вы можете воспользоваться любой переменной из Вашей программы через подпрограмму. В качестве примера приведем следующую программу. Она принимает два числа и выводит наибольшее из них. Обратите внимание на то, что переменная max используется как внутри, так и снаружи подпрограммы.
TextWindow.Write("Введите первое число: ")
num1 = TextWindow.ReadNumber()
TextWindow.Write("Введите второе число: ")
num2 = TextWindow.ReadNumber()
FindMax()
TextWindow.WriteLine("Большее число: " + max)
Sub FindMax
If (num1 > num2) Then
max = num1
Else
max = num2
EndIf
EndSub
Результат выполнения этой программы выглядит следующим образом.
Рисунок 45 – Вывод наибольшего по значению числа с помощью подпрограммы
Давайте приведем еще один пример использования подпрограммы. На этот раз мы воспользуемся графической программой, которая вычисляет пару координат, и хранит эти значения в переменных x
и y
. Потом она вызывает подпрограмму DrawCircleUsingCenter
, которая отвечает за рисование круга, и использует x
и y
в качестве координат центра.
GraphicsWindow.BackgroundColor = "Black"
GraphicsWindow.PenColor = "LightBlue"
GraphicsWindow.Width = 480
For i = 0 To 6.4 Step 0.17
x = Math.Sin(i) * 100 + 200
y = Math.Cos(i) * 100 + 200
DrawCircleUsingCenter()
EndFor
Sub DrawCircleUsingCenter
startX = x - 40
startY = y - 40
GraphicsWindow.DrawEllipse(startX, startY, 120, 120)
EndSub
Рисунок 46 – Пример использования Подпрограммы в графике
Вызов подпрограмм из циклов
Иногда подпрограммы можно вызвать из цикла, во время выполнения которого они выполняют тот же набор команд, но с другими значениями одной или нескольких переменных. Например, одна из подпрограмм, которая называется PrimeCheck
, определяет, простое число или нет. Можно написать программу, которая позволит пользователю ввести значение и потом, используя эту подпрограмму, сообщит простое оно или нет. Данный пример хорошо иллюстрирует следующая программа.
TextWindow.Write("Введите число: ")
i = TextWindow.ReadNumber()
isPrime = "True"
PrimeCheck()
If (isPrime = "True") Then
TextWindow.WriteLine(i + " – простое число.")
Else
TextWindow.WriteLine(i + " – не простое число.")
EndIf
Sub PrimeCheck
For j = 2 To Math.SquareRoot(i)
If (Math.Remainder(i, j) = 0) Then
isPrime = "False"
Goto EndLoop
EndIf
Endfor
EndLoop:
EndSub
Подпрограмма PrimeCheck
принимает значение переменной i
и делит его на его возможные делители. Если i
поделится без остатка, то i
не является простым числом. В этот момент подпрограмма присваивает переменной isPrime
значение “False
” («Ложь») и выходит из программы. Если число не разделилось ни на один из возможных делителей, то значение переменной isPrime
остается “True
” («Истина»).
Рисунок 47 – Вычисление простого числа
Теперь, когда у Вас есть подпрограмма, которая вычисляет простые числа, можно попробовать выбрать все простые числа, например, до 100. Для этого можно легко изменить вышеприведенную программу и сделать возможным вызов PrimeCheck
из цикла. Так, при каждом выполнении цикла подпрограмма будет вычислять разные значения. Давайте посмотрим, как это происходит на нижеприведенном примере.
For i = 3 To 100
isPrime = "True"
PrimeCheck()
If (isPrime = "True") Then
TextWindow.WriteLine(i)
EndIf
EndFor
Sub PrimeCheck
For j = 2 To Math.SquareRoot(i)
If (Math.Remainder(i, j) = 0) Then
isPrime = "False"
Goto EndLoop
EndIf
Endfor
EndLoop:
EndSub
В вышеприведенной программе значение переменной i
меняется каждый раз при выполнении цикла. Внутри цикла происходит вызов подпрограммы PrimeCheck
. Потом PrimeCheck
определяет значение i
и вычисляет, является i
простым числом или нет. Результат сохраняется в переменной isPrime
, к которой потом получает доступ цикл снаружи подпрограммы. Потом значение i
выводится на экран, в случае, если оно оказывается простым числом. А так как цикл начинает проверку значений с 3 и заканчивает 100, то мы получим список всех простых чисел от 3 до 100. Ниже Вы видите результат программы.
Рисунок 48 – Простые числа
10. Массивы
К этому моменту Вы уже должны хорошо представлять, как использовать переменные.
Давайте посмотрим еще раз на нашу первую программу с переменными:
TextWindow.Write("Введите Ваше имя: ")
name = TextWindow.Read()
TextWindow.WriteLine("Привет, " + name)
В этой программе пользователь вводил с клавиатуры имя, а мы его сохраняли в переменной name. Затем мы говорили пользователю «Привет» и выводили на экран его имя. Теперь давайте представим, что у нас не один, а пять пользователей. Каким образом можно сохранить имена всех пользователей? Вот один из путей решения этой задачи.
TextWindow.Write("Пользователь 1, введите Ваше имя: ")
name1 = TextWindow.Read()
TextWindow.Write("Пользователь 2, введите Ваше имя: ")
name2 = TextWindow.Read()
TextWindow.Write("Пользователь 3, введите Ваше имя: ")
name3 = TextWindow.Read()
TextWindow.Write("Пользователь 4, введите Ваше имя: ")
name4 = TextWindow.Read()
TextWindow.Write("Пользователь 5, введите Ваше имя: ")
name5 = TextWindow.Read()
TextWindow.Write("Привет, ")
TextWindow.Write(name1 + ", ")
TextWindow.Write(name2 + ", ")
TextWindow.Write(name3 + ", ")
TextWindow.Write(name4 + ", ")
TextWindow.WriteLine(name5)
Вот результаты выполнения этой программы:
Рисунок 49 – Без массивов
Очевидно, что должен быть более простой путь. Компьютер предназначен для того, чтобы выполнять повторяющиеся задачи. Зачем нам тогда писать один и тот же код снова и снова? Для решения этой задачи можно использовать одну и ту же переменную, которая будет хранить несколько имен. Для этого нам надо использовать цикл For
, который мы рассматривали в предыдущих главах. И вот тут нам потребуются массивы.
Что такое массив?
Массивы — это специальный вид переменных, которые могут хранить несколько значений одновременно. Это означает, что вместо создания пяти обычных переменных name1
, name2
, name3
, name4
и name5
для хранения пяти имен пользователей можно использовать массив name
для хранения всех имен. Хранить несколько значений позволяет так называемый индекс. Например, каждый элемент name[1], name[2], name[3], name[4] и name[5] может хранить одно значение. Числа 1, 2, 3, 4 и 5 называются индексами для этого массива.
Хотя name[1]
, name[2]
, name[3]
, name[4]
и name[5]
выглядят как разные переменные, они на самом деле являются частью одной переменной. Какие же преимущества дают массивы? Когда значения хранятся в массиве, к индексам можно обращаться с помощью другой переменной. Это свойство позволяет работать с массивами в циклах.
Давайте посмотрим, как может быть переписана предыдущая программа с применением массивов.
For i = 1 To 5
TextWindow.Write("Пользователь " + i + ", введите Ваше имя: ")
name[i] = TextWindow.Read()
EndFor
TextWindow.Write("Привет, ")
For i = 1 To 5
TextWindow.Write(name[i] + ", ")
EndFor
TextWindow.WriteLine("")
Намного проще, не правда ли? Обратите внимание на две выделенные строки. Первая сохраняет значение в массиве, а вторая читает значение из массива. Значение, сохраняемое в name[1]
, не зависит от значения, сохраняемого в name[2]
. Поэтому в большинстве случаев можно рассматривать name[1]
и name[2]
как две независимые переменные внутри одного массива.
Рисунок 50 – С использованием массивов
Программа выше выдает такой же результат, как и программа без массивов, за исключением запятой после последнего имени Кристофер Робин. Это может быть исправлено следующим образом:
TextWindow.Write("Привет, ")
For i = 1 To 5
TextWindow.Write(name[i])
If i < 5 Then
TextWindow.Write(", ")
EndIf
EndFor
TextWindow.WriteLine("")
Индексация массива
В нашей предыдущей программе мы использовали числа в качестве индексов массива. Однако индексами могут быть не только числа, но и текст. Например, в следующей программе мы предложим пользователю ввести различные данные о себе, а выведем на экран только те данные, которые пользователь попросит.
TextWindow.Write("Введите Ваше имя: ")
user["name"] = TextWindow.Read()
TextWindow.Write("Введите Ваш возраст: ")
user["возраст"] = TextWindow.Read()
TextWindow.Write("Введите страну: ")
user["страна"] = TextWindow.Read()
TextWindow.Write("Введите город: ")
user["город"] = TextWindow.Read()
TextWindow.Write("Какие данные необходимо вывести? ")
index = TextWindow.Read()
TextWindow.WriteLine(index + " = " + user[index])
Рисунок 51 – Использование нечисловых индексов
Несколько измерений
Предположим, Вы хотите хранить имена и телефонные номера всех Ваших друзей и иметь возможность находить телефонные номера, когда они нужны, примерно как в мобильном телефоне. Как можно написать такую программу?
В этом случае потребуется два набора индексов, которые называются измерениями массива. Предположим, что каждому другу мы дадим короткое имя. Это короткое имя можно использовать в качестве первого индекса массива. Если в качестве первого индекса используется короткое имя, то второй индекс Имя
и Телефон
позволит получить доступ к полному имени и телефонному номеру каждого друга.
Индексы массива не зависят от регистра. Как и в случае обычных переменных, буквы индексов массива могут иметь разный регистр.
Хранить данные мы сможем следующим образом:
friends["Крис"]["Имя"] = "Кристофер Робин"
friends["Крис"]["Телефон"] = "987-6543"
friends["Иа"]["Имя"] = "Иа-иа"
friends["Иа"]["Телефон"] = "987-5634"
friends["Винни"]["Имя"] = "Винни-Пух"
friends["Винни"]["Телефон"] = "987-4365"
Так как для одного и того же массива friend
s используется два индекса, этот массив называется двумерным.
В этой программе мы попросим ввести короткое имя, а затем по этому имени выведем все данные о друге. Вот полный текст программы:
friends["Крис"]["Имя"] = "Кристофер Робин"
friends["Крис"]["Телефон"] = "987-6543"
friends["Иа"]["Имя"] = "Иа-иа"
friends["Иа"]["Телефон"] = "987-5634"
friends["Винни"]["Имя"] = "Винни-Пух"
friends["Винни"]["Телефон"] = "987-4365"
TextWindow.Write("Введите короткое имя: ")
nickname = TextWindow.Read()
TextWindow.WriteLine("Имя: " + friends[nickname]["Имя"])
TextWindow.WriteLine("Телефон: " + friends[nickname]["Телефон"])
Рисунок 52 – Простая телефонная книга
Работа с таблицами
Часто многомерные массивы используются для работы с таблицами. Столбцы и строки таблиц легко представить в виде двумерного массива. Ниже приведен пример простой программы, которая расставляет разноцветные квадратики внутри большого квадрата.
rows = 8
columns = 8
size = 40
For r = 1 To rows
For c = 1 To columns
GraphicsWindow.BrushColor = GraphicsWindow.GetRandomColor()
boxes[r][c] = Shapes.AddRectangle(size, size)
Shapes.Move(boxes[r][c], c * size, r * size)
EndFor
EndFor
Эта программа создает маленькие квадратики и располагает их внутри большого квадрата 8 х 8. Кроме того, она сохраняет все маленькие квадратики в массиве. Хранение в массиве помогает отслеживать квадратики и использовать их снова.
Рисунок 53 – Разноцветные квадратики
Например, если добавить следующий код в конец предыдущей программы, квадратики будут перемещаться в левый верхний угол.
For r = 1 To rows
For c = 1 To columns
Shapes.Animate(boxes[r][c], 0, 0, 1000)
Program.Delay(300)
EndFor
EndFor
Рисунок 54 – Перемещающиеся квадратики
11. События и интерактивность
В первых двух главах мы познакомили Вас с объектами, у которых есть Свойства и Операции. Дополнительно к свойствам и операциям некоторые объекты обладают такой функцией как События. События как сигналы, которые возникают, например, в ответ на такие действия пользователя как передвижение мышки или нажатие на нее. В некотором понимании, события – это нечто противоположное операциям. В случае с операцией, Вы, как пользователь, вызываете ее, чтобы заставить компьютер сделать что-нибудь; а в случае с событиями, компьютер дает Вам знать, когда что-нибудь происходит.
Чем полезны события?
События являются центральным ядром в работе интерактивной программы. Если вы хотите позволить пользователю взаимодействовать с вашей программой, вы будете делать это с помощью событий. Например, Вы пишите игру Tic-Tac-Toe. Вы захотите сделать так, чтобы у пользователя было право выбора на его/ее игру, так? Вот здесь нам и пригодятся события – Вы получаете введенные пользователем данные снаружи программы при помощи событий. Если это сложно понять, не переживайте, мы подробно рассмотрим очень простой пример, на котором будет понятно, что такое события и как им найти применение.
Внизу приведена очень простая программа, которая имеет всего одно предложение и одну подпрограмму. Подпрограмма использует операцию ShowMessage
в объекте Графическое Окно для отображения окна сообщений пользователю.
GraphicsWindow.MouseDown = OnMouseDown
Sub OnMouseDown
GraphicsWindow.ShowMessage("Вы щелкнули мышью.", "Привет!")
EndSub
Обратите внимание на одну интересную часть приведенной выше программы – строка, в которой мы присваиваем имя подпрограммы событию MouseDown
, принадлежащего объекту GraphicsWindow
(Графическое Окно). Заметьте, что MouseDown
очень похоже на свойство, за исключением одного – вместо присваивания ему какого-либо значения мы присваиваем ему подпрограмму OnMouseDown
. Вот что является отличительной особенностью событий – когда происходит событие, подпрограмма вызывается автоматически. В данном случае подпрограмма OnMouseDown
вызывается при каждом нажатии мышкой на Графическое Окно. Теперь запустите программу и посмотрите на результат. При каждом нажатии на Графическое Окно мышкой на экране будет появляться такое же окно сообщений, как Вы видите ниже.
Рисунок 55 – Реакция на событие
Такой способ использования событий очень эффективен и позволяет создавать креативные и интересные программы. Программы, написанные по такому принципу, часто называются событийно-ориентированными.
Подпрограмму OnMouseDown
можно изменить так, чтобы она выполняла другие действия помимо вывода на экран окна сообщений. Например, как в нижеприведенной программе, пользователь может рисовать большие синие точки, нажимая на мышку.
GraphicsWindow.BrushColor = "Blue"
GraphicsWindow.MouseDown = OnMouseDown
Sub OnMouseDown
x = GraphicsWindow.MouseX - 10
y = GraphicsWindow.MouseY - 10
GraphicsWindow.FillEllipse(x, y, 20, 20)
EndSub
Рисунок 56 – Использование события Mouse Down
Обратите внимание на то, что в этой программе мы использовали MouseX
и MouseY
для определения координат мышки. Потом мы рисуем круг, используя координаты мышки в качестве центра круга.
Работа с несколькими событиями
Количество событий, с которыми Вы можете работать, не ограничено. Можно работать с несколькими событиями, используя одну подпрограмму. Несмотря на это, событием можно воспользоваться только один раз. Если Вы попробуете одному событию присвоить две подпрограммы — присвоится последняя.
Чтобы проиллюстрировать это, давайте обратимся к предыдущему примеру и добавим подпрограмму, которая выполняется при нажатии клавиш. Давайте также заставим подпрограмму изменить цвет кисти, чтобы при нажатии на мышку получалась точка другого цвета.
GraphicsWindow.BrushColor = "Blue"
GraphicsWindow.MouseDown = OnMouseDown
GraphicsWindow.KeyDown = OnKeyDown
Sub OnKeyDown
GraphicsWindow.BrushColor = GraphicsWindow.GetRandomColor()
EndSub
Sub OnMouseDown
x = GraphicsWindow.MouseX - 10
y = GraphicsWindow.MouseY - 10
GraphicsWindow.FillEllipse(x, y, 20, 20)
EndSub
Рисунок 57 – Работа с несколькими событиями
Если Вы запустили эту программу и кликнули на окно, то у Вас получится синяя точка. Потом, если Вы нажмете на любую клавишу один раз и снова кликнете, у Вас получится точка другого цвета. Таким образом, при нажатии клавиши выполняется подпрограмма OnKeyDown
, которая изменяет цвет кисти на случайный. После этого, когда Вы нажмете на мышку, появится круг, нарисованный с помощью новой паллеты цветов — точками случайного цвета.
Программа для рисования
Вооружившись событиями и подпрограммами, нам теперь несложно будет написать программу, с помощью которой можно рисовать на окне. Написать такую программу на самом деле не составит никакого труда, при условии, что мы разобьем эту задачу на несколько небольших частей. Для начала, давайте напишем программу, с помощью которой пользователь сможет двигать мышкой по графическому окну в любом направлении, оставляя за собой след.
GraphicsWindow.MouseMove = OnMouseMove
Sub OnMouseMove
x = GraphicsWindow.MouseX
y = GraphicsWindow.MouseY
GraphicsWindow.DrawLine(prevX, prevY, x, y)
prevX = x
prevY = y
EndSub
При этом, когда Вы запускаете программу, первая строка всегда начинается в верхнем левом углу окна (0,0). Эту проблему можно решить с помощью события MouseDown
, и вводом значений prevX
и prevY
, когда это событие произойдет.
Кроме того, нам нужно, чтобы след оставался только при нажатии на кнопку мыши. Нам не нужно, чтобы линии оставалась в других случаях. Для этого мы воспользуемся свойством IsLeftButtonDown
на объекте Мышь. С его помощью мы сможем понять, нажата ли кнопка мыши или нет. Если значение верное, то линия будет нарисована, если нет – мы пропускаем строку.
GraphicsWindow.MouseMove = OnMouseMove
GraphicsWindow.MouseDown = OnMouseDown
Sub OnMouseDown
prevX = GraphicsWindow.MouseX
prevY = GraphicsWindow.MouseY
EndSub
Sub OnMouseMove
x = GraphicsWindow.MouseX
y = GraphicsWindow.MouseY
If (Mouse.IsLeftButtonDown) Then
GraphicsWindow.DrawLine(prevX, prevY, x, y)
EndIf
prevX = x
prevY = y
EndSub
12. Примеры развлечений
Фрактал с Черепашкой
Рисунок 58 – Черепашка рисует фрактальное дерево
angle = 30
delta = 10
distance = 60
Turtle.Speed = 9
GraphicsWindow.BackgroundColor = "Black"
GraphicsWindow.PenColor = "LightGreen"
DrawTree()
Sub DrawTree
If (distance > 0) Then
Turtle.Move(distance)
Turtle.Turn(angle)
Stack.PushValue("distance", distance)
distance = distance - delta
DrawTree()
Turtle.Turn(-angle * 2)
DrawTree()
Turtle.Turn(angle)
distance = Stack.PopValue("distance")
Turtle.Move(-distance)
EndIf
EndSub
Фотографии с сайта Flickr
Рисунок 59 – Загрузка фотографий с Flickr
GraphicsWindow.BackgroundColor = "Black"
GraphicsWindow.MouseDown = OnMouseDown
Sub OnMouseDown
pic = Flickr.GetRandomPicture("mountains, river")
GraphicsWindow.DrawResizedImage(pic, 0, 0, 640, 480)
EndSub
Flickr.com –интернет-сервис, предназначенный для хранения и дальнейшего использования пользователем своих цифровых фотографий и видеороликов.
Динамические Обои
Эта программа будет менять обои вашего рабочего стола MS Windows с интервалом в 10 секунд, выбирая произвольные фотографии тематики «горы» с сервиса Flickr.com.
For i = 1 To 10
pic = Flickr.GetRandomPicture("mountains")
Desktop.SetWallPaper(pic)
Program.Delay(10000)
EndFor
Игра Paddle
Рисунок 60 – Игра Paddle
GraphicsWindow.BackgroundColor = "DarkBlue"
paddle = Shapes.AddRectangle(120, 12)
ball = Shapes.AddEllipse(16, 16)
GraphicsWindow.MouseMove = OnMouseMove
x = 0
y = 0
deltaX = 1
deltaY = 1
RunLoop:
x = x + deltaX
y = y + deltaY
gw = GraphicsWindow.Width
gh = GraphicsWindow.Height
If (x >= gw - 16 or x <= 0) Then
deltaX = -deltaX
EndIf
If (y <= 0) Then
deltaY = -deltaY
EndIf
padX = Shapes.GetLeft(paddle)
If (y = gh - 28 and x >= padX and x <= padX + 120) Then
deltaY = -deltaY
EndIf
Shapes.Move(ball, x, y)
Program.Delay(5)
If (y < gh) Then
Goto RunLoop
EndIf
GraphicsWindow.ShowMessage("Вы проиграли", "Paddle")
Sub OnMouseMove
paddleX = GraphicsWindow.MouseX
Shapes.Move(paddle, paddleX - 60, GraphicsWindow.Height - 12)
EndSub
13. Цвета
Ниже дан список цветов с их названиями, которые поддерживаются в Small Basic.
Красные цвета
IndianRed | #CD5C5C |
LightCoral | #F08080 |
Salmon | #FA8072 |
DarkSalmon | #E9967A |
LightSalmon | #FFA07A |
Crimson | #DC143C |
Red | #FF0000 |
FireBrick | #B22222 |
DarkRed | #8B0000 |
Розовые цвета
Pink | #FFC0CB |
LightPink | #FFB6C1 |
HotPink | #FF69B4 |
DeepPink | #FF1493 |
MediumVioletRed | #C71585 |
PaleVioletRed | #DB7093 |
Оранжевые цвета
LightSalmon | #FFA07A |
Coral | #FF7F50 |
Tomato | #FF6347 |
OrangeRed | #FF4500 |
DarkOrange | #FF8C00 |
Orange | #FFA500 |
Желтые цвета
Gold | #FFD700 |
Yellow | #FFFF00 |
LightYellow | #FFFFE0 |
LemonChiffon | #FFFACD |
LightGoldenrodYellow | #FAFAD2 |
PapayaWhip | #FFEFD5 |
Moccasin | #FFE4B5 |
PeachPuff | #FFDAB9 |
PaleGoldenrod | #EEE8AA |
Khaki | #F0E68C |
DarkKhaki | #BDB76B |
Фиолетовые цвета
Lavender | #E6E6FA |
Thistle | #D8BFD8 |
Plum | #DDA0DD |
Violet | #EE82EE |
Orchid | #DA70D6 |
Fuchsia | #FF00FF |
Magenta | #FF00FF |
MediumOrchid | #BA55D3 |
MediumPurple | #9370DB |
BlueViolet | #8A2BE2 |
DarkViolet | #9400D3 |
DarkOrchid | #9932CC |
DarkMagenta | #8B008B |
Purple | #800080 |
Indigo | #4B0082 |
SlateBlue | #6A5ACD |
DarkSlateBlue | #483D8B |
MediumSlateBlue | #7B68EE |
Зеленые цвета
GreenYellow | #ADFF2F |
Chartreuse | #7FFF00 |
LawnGreen | #7CFC00 |
Lime | #00FF00 |
LimeGreen | #32CD32 |
PaleGreen | #98FB98 |
LightGreen | #90EE90 |
MediumSpringGreen | #00FA9A |
SpringGreen | #00FF7F |
MediumSeaGreen | #3CB371 |
SeaGreen | #2E8B57 |
ForestGreen | #228B22 |
Green | #008000 |
DarkGreen | #006400 |
YellowGreen | #9ACD32 |
OliveDrab | #6B8E23 |
Olive | #808000 |
DarkOliveGreen | #556B2F |
MediumAquamarine | #66CDAA |
DarkSeaGreen | #8FBC8F |
LightSeaGreen | #20B2AA |
DarkCyan | #008B8B |
Teal | #008080 |
Синие цвета
Aqua | #00FFFF |
Cyan | #00FFFF |
LightCyan | #E0FFFF |
PaleTurquoise | #AFEEEE |
Aquamarine | #7FFFD4 |
Turquoise | #40E0D0 |
MediumTurquoise | #48D1CC |
DarkTurquoise | #00CED1 |
CadetBlue | #5F9EA0 |
SteelBlue | #4682B4 |
LightSteelBlue | #B0C4DE |
PowderBlue | #B0E0E6 |
LightBlue | #ADD8E6 |
SkyBlue | #87CEEB |
LightSkyBlue | #87CEFA |
DeepSkyBlue | #00BFFF |
DodgerBlue | #1E90FF |
CornflowerBlue | #6495ED |
MediumSlateBlue | #7B68EE |
RoyalBlue | #4169E1 |
Blue | #0000FF |
MediumBlue | #0000CD |
DarkBlue | #00008B |
Navy | #000080 |
MidnightBlue | #191970 |
Коричневые цвета
Cornsilk | #FFF8DC |
BlanchedAlmond | #FFEBCD |
Bisque | #FFE4C4 |
NavajoWhite | #FFDEAD |
Wheat | #F5DEB3 |
BurlyWood | #DEB887 |
Tan | #D2B48C |
RosyBrown | #BC8F8F |
SandyBrown | #F4A460 |
Goldenrod | #DAA520 |
DarkGoldenrod | #B8860B |
Peru | #CD853F |
Chocolate | #D2691E |
SaddleBrown | #8B4513 |
Sienna | #A0522D |
Brown | #A52A2A |
Maroon | #800000 |
Белые цвета
White | #FFFFFF |
Snow | #FFFAFA |
Honeydew | #F0FFF0 |
MintCream | #F5FFFA |
Azure | #F0FFFF |
AliceBlue | #F0F8FF |
GhostWhite | #F8F8FF |
WhiteSmoke | #F5F5F5 |
Seashell | #FFF5EE |
Beige | #F5F5DC |
OldLace | #FDF5E6 |
FloralWhite | #FFFAF0 |
Ivory | #FFFFF0 |
AntiqueWhite | #FAEBD7 |
Linen | #FAF0E6 |
LavenderBlush | #FFF0F5 |
MistyRose | #FFE4E1 |
Серые цвета
Gainsboro | #DCDCDC |
LightGray | #D3D3D3 |
Silver | #C0C0C0 |
DarkGray | #A9A9A9 |
Gray | #808080 |
DimGray | #696969 |
LightSlateGray | #778899 |
SlateGray | #708090 |
DarkSlateGray | #2F4F4F |
Black | #000000 |
14. Обсуждение
Обсудить данную статью можно на нашем Форуме или в комментариях.