[an error occurred while processing this directive]
<pre>

─PL63
─LS1
─SRP 27
─TM0
─HM2
─DH//-|P-//
─LM5
│..................................................................&lt;
        3.3 Вывод информации. Форматирование печати

     Вывод (распечатка) информации в программе&nbsp; на&nbsp; языке&nbsp; BASIC,
как&nbsp; известно,&nbsp; осуществляется с помощью оператора PRINT на экран
дисплея, либо на&nbsp; печатающее&nbsp; устройство (принтер). Вид выводимой
информации указывается в списке имен&nbsp; переменных оператора PRINT,
которые могут быть числовыми и (или) символьными.
     При&nbsp; исполнении&nbsp; оператора&nbsp; PRINT&nbsp;  под&nbsp;&nbsp; каждую&nbsp;&nbsp; выводимую
переменную&nbsp; автоматически&nbsp; отводится&nbsp; поле, состоящее&nbsp; из&nbsp; десяти
позиций экрана. Можно представить&nbsp; себе,&nbsp; что&nbsp; строка&nbsp; экрана или
принтера&nbsp;&nbsp; разбита&nbsp;&nbsp; на&nbsp;&nbsp; определенное&nbsp;&nbsp; количество&nbsp;&nbsp; колонок&nbsp; (в
зависимости от числа символов в строке) по десять позиций каждая.
     Значения&nbsp; числовых&nbsp; переменных&nbsp; выводятся&nbsp; в соответствующих
полях заполняя позиции справа, а&nbsp; символьных&nbsp; переменных - слева.
Это наглядно иллюстрируется следующим простым фрагментом:
       10 X=8
       20 A&curren;="HELLO"
       30 PRINT X,X/2,X/4
       40 PRINT A&curren;,A&curren;,A&curren;
       &gt;RUN
         8         4         2
HELLO     HELLO     HELLO

     Количество полей в строке будет&nbsp; различным&nbsp; в зависимости от
возможного&nbsp; экранного&nbsp; режима. Всего для ПЭВМ могут&nbsp; быть&nbsp; заданы
восемь&nbsp; экранных&nbsp; режимов,&nbsp; отличающихся&nbsp; количеством&nbsp; символьных
позиций&nbsp;&nbsp; в&nbsp; строке,&nbsp;&nbsp; наличием&nbsp;&nbsp; или&nbsp;&nbsp; отсутствием&nbsp;&nbsp; графичиских
возможностей,&nbsp; числом&nbsp; цветов,&nbsp;&nbsp; кодировкой&nbsp;&nbsp; символов,&nbsp;&nbsp; обьемом
резервируемой&nbsp; под вывод&nbsp; на&nbsp; экран&nbsp; оперативной&nbsp; памяти&nbsp; и&nbsp; т.д.
(см.также приложение&nbsp; II). Однако, в различных экранных режимах с
точки зрения количества&nbsp; позиций&nbsp; в&nbsp; строке,&nbsp; возможны&nbsp; лишь&nbsp; три
варианта&nbsp; - 20,40 и 80 позиций. Экранный режим задается с помощью
команды MODE. Формат команды
              MODE n   ,
     где n-номер режима, изменяется от&nbsp; 0&nbsp; до&nbsp; 7. Применительно к
количеству&nbsp; символьных&nbsp; позиций&nbsp; в&nbsp; строке&nbsp; экранные режимы можно
разделить на группы: 0,3 - 80&nbsp; позиций&nbsp; (8&nbsp; полей)&nbsp; 1,4,6,7&nbsp; - 40
позиций (4 поля); 2,5 - 20 позиций (2 поля).
     Использование&nbsp;&nbsp; оператора&nbsp;&nbsp; PRINT&nbsp; предполагает&nbsp; возможность
исключения форматирования выводимых значений переменных с помощью
полей.&nbsp;&nbsp; В&nbsp; этом&nbsp; случае&nbsp; выводимая&nbsp; информация&nbsp; отображается&nbsp; на
устройстве&nbsp;&nbsp; вывода&nbsp;&nbsp; в&nbsp;&nbsp; соответствии&nbsp;&nbsp; со&nbsp; списком&nbsp; переменных,
разделяемых&nbsp; символом&nbsp; ; , сплошным образом (без пропуска позиций
между значениями соседних&nbsp; в&nbsp; списке&nbsp; переменных). Иллюстрацией к
этому является пример: 
             10 X=8
             20 A&curren;="HELLO"
             30 PRINT X;A&curren;;X
            &gt;RUN
                     8HELLO8
     Отметим также,что символ ; может эффективно использоваться в
конце списка вывода. В этом&nbsp; случае&nbsp; его&nbsp; действие&nbsp; заключается в
отсутствии&nbsp; перевода&nbsp; строки&nbsp; после&nbsp; вывода значений переменных в
списке&nbsp; или&nbsp; текстовой строки (литерала)&nbsp; опертора&nbsp; PRINT.&nbsp; Такую
форму удобно применять при организации диалоговых программ, когда
вводимая пользователем программы&nbsp; информация&nbsp; является ответом на
некоторый&nbsp; вопрос&nbsp; и&nbsp; собственно ввод&nbsp; осуществляется&nbsp; в&nbsp; той&nbsp; же
строке,в&nbsp; которой располагается текст&nbsp; вопроса.&nbsp; Например,&nbsp; такой
фрагмент программы 
             10 PRINT "Как вас зовут";
             20 INPUT Name&curren;
             30 PRINT "Добрый день, "; Name&curren;;"!"
                RUN
        Как вас зовут? Николай 
        Добрый день, Николай!

     Наличие символа ; в конце оператора 10 позволило осуществить
ввод значения переменной Name&curren; (оператор 20) в той же строке. 
     При&nbsp; распечатке числовой информации форматирование выводимых
строк с помощью полей является удобным. Наряду с этим хотелось бы
иметь возможность&nbsp; управлять&nbsp; размером поля (особенно полезно для
формирования таблиц), а также&nbsp; при&nbsp; выводе&nbsp; вещественных&nbsp; чисел -
количеством&nbsp; распечатываемых цифр после запятой с соответствующим
округлением. В&nbsp; качестве&nbsp; средства&nbsp; для&nbsp; этих целей в языке BASIC
используется&nbsp;   специальная&nbsp; резидентная&nbsp; в&nbsp; памяти переменая &nbsp;%.
Управление&nbsp; форматированием&nbsp; вывода&nbsp; осуществляется установкой ее
значения&nbsp; с&nbsp; помощью&nbsp; команды&nbsp;&nbsp; или&nbsp;&nbsp; оператора&nbsp;&nbsp; присваивания&nbsp; в
программе, предшествующих выполнению оператора PRINT. 

     Значение,&nbsp;&nbsp; приваиваемое&nbsp;&nbsp; переменной&nbsp; &nbsp;%,&nbsp; имеет&nbsp; следующую
структуру 
                     &nbsp;%=&мn1n2
     Здесь символ &-указывает на то,&nbsp; что&nbsp; значение целочисленной
переменной&nbsp;&nbsp;&nbsp; &nbsp;%&nbsp;&nbsp; представлено&nbsp;&nbsp; в&nbsp;&nbsp; шестнадцатиричной&nbsp;&nbsp; системе
исчисления,&nbsp; а&nbsp; м&nbsp; -&nbsp; номер&nbsp; формата, определяющего представление
вещественных чисел при выводе. Возможные значения м:
     1-вывод вещественных чисел в экспоненцианальной форме;          
     2-вывод вещественных чисел с десятичной точкой;
     0-стандартный формат вывода, устанавливаемый автоматически при 
       включении ПЭВМ (по умолчанию).
     Далее, n1 (две позиции) - количество выводимых значащих цифр
после десятичной точки для вещественных чисел, n2 (две позиции) -
количество&nbsp;&nbsp; позиций&nbsp;&nbsp; в&nbsp; выводимом&nbsp; поле&nbsp;&nbsp; (размер&nbsp;&nbsp; поля)&nbsp;&nbsp; при
форматировании строки.
     Отметим, что п1, п2 -&nbsp; задаются&nbsp; в шестнадцатиричной системе
исчисления.
     Предположим, что вывод информации осуществляется&nbsp; по формату
2, требуется 3 значещих цифры после&nbsp; десятичной&nbsp; точки,&nbsp; а&nbsp; длина
поля&nbsp;&nbsp; -&nbsp;&nbsp; 8&nbsp;&nbsp; позиций.&nbsp; Этот&nbsp; вариант&nbsp; иллюстрируется&nbsp; следующим
фрагментом:
               10 &nbsp;%=&20308
               20 X=7
               30 PRINT X,X+2,X/3,X*X
               &gt;RUN
               7.000  9.000  2.333  49.000
     Пусть&nbsp; те&nbsp; же&nbsp; значения&nbsp; мы&nbsp;&nbsp; хотим&nbsp;&nbsp; вывести&nbsp;&nbsp; на&nbsp; экран&nbsp; в
экспоненциональной&nbsp; форме&nbsp; (фомат&nbsp; 1),&nbsp; тогда&nbsp;&nbsp; оператор&nbsp;&nbsp; 10&nbsp;&nbsp; в
приведенном фрагменте примет вид
               10&nbsp; &nbsp;%=&10308     ,&nbsp;
 а по команде RUN на экране появляется следующий результат:
               7.00Е0  9.00Е0  2.33Е0  4.90Е1
     Для станартного формата вывода (формат&nbsp; 0):&nbsp; длина&nbsp; поля&nbsp; 10
позиций,&nbsp; девять значащих цифр после десятичной точки, переменная
&nbsp;% имеет следующее значение
                      &nbsp;%=&90A
     Напомним,&nbsp; что&nbsp; А&nbsp; в&nbsp; шестнадцатиричной&nbsp; системе&nbsp; исчисления
обозначает число 10.
     Возможен случай, когда выводимое число или символьная строка
не&nbsp; помещается&nbsp; в&nbsp; отведенном&nbsp; поле.&nbsp; Например,&nbsp; задано&nbsp; значение
специальной переменной &nbsp;%=&20507 (формат 2,&nbsp; пять&nbsp; значащих&nbsp; цифр
после&nbsp; десятичной&nbsp; точки,&nbsp; длина поля 7). В этом случае некоторые
числа, например 125.98731, не&nbsp; могут&nbsp; быть размещены, так как для
них&nbsp; требуется&nbsp; 9&nbsp; позиций.&nbsp; В&nbsp; таких&nbsp;&nbsp; ситуациях&nbsp;&nbsp; автоматически
присоединяется&nbsp;&nbsp; соседнее&nbsp;&nbsp; поле&nbsp;&nbsp; справа&nbsp;&nbsp; от&nbsp;&nbsp; отведенного,&nbsp; и,
соответственно,&nbsp; текущее&nbsp; поле&nbsp; для вывода следующей переменной в
списке оператора PRINT смещается&nbsp; на одно поле вправо. Если полей
в строке (количество зависит от&nbsp; экранного&nbsp; режима) не достаточно
для&nbsp; вывода&nbsp; всех переменных списка, автоматически при выполнении
оператора PRINT осуществляет переход к следующим строкам.
     Рассмотрим&nbsp;&nbsp; теперь&nbsp; еще&nbsp; некоторые&nbsp; возможности&nbsp; размещения
выводимой&nbsp;&nbsp; символьной&nbsp; информации&nbsp; по&nbsp; усмотрению&nbsp; пользователя,
представляемые языком BASIC. Прежде всего обратим внимание на то,
что&nbsp; различным&nbsp; экранным&nbsp; режимам, устанавливаемым командой MODE,
соответсвует не только разное&nbsp; количество символов в строке, но и
разное&nbsp; число&nbsp; самих&nbsp; строк,&nbsp; размещаемых&nbsp;&nbsp; на&nbsp; экране.&nbsp; В&nbsp; целом
схематично экран при выводе символьной (не графической, см.п.4.2)
информации&nbsp;&nbsp; может&nbsp;&nbsp; быть&nbsp;&nbsp; представлен&nbsp;&nbsp; в&nbsp;&nbsp;&nbsp; виде&nbsp;&nbsp; дискретного
прямоугольника, состоящего из M x N соответственно по вертикали и
горизонтали клеточек (позиций для отображения символов).
                                    
                         MODE 0 - 32 * 80
                         MODE 1 - 32 * 40
                         MODE 2 - 32 * 20
                         MODE 3 - 25 * 80
                         MODE 4 - 32 * 40
                         MODE 5 - 32 * 20
                         MODE 6 - 25 * 40
                         MODE 7 - 25 * 40

     Таким образом, каждая позиция курсора&nbsp; на&nbsp; экране может быть
задана&nbsp;&nbsp; (адресована)&nbsp;&nbsp; с&nbsp;&nbsp; помощью&nbsp;&nbsp; двух&nbsp;&nbsp; координат&nbsp;&nbsp; по&nbsp; осям
Х-горизонталь&nbsp; (номер&nbsp; позиции&nbsp; в&nbsp; строке,&nbsp; слева&nbsp; от 0 до N-1) и
Y-вертикаль (номер строки, сверху от 0 до М-1).
     Первым&nbsp;&nbsp;&nbsp; расматриваемым&nbsp;&nbsp;&nbsp; средством&nbsp;&nbsp;&nbsp; языка&nbsp;&nbsp; BASIC&nbsp;&nbsp; для
осуществления&nbsp; вывода&nbsp; символьной&nbsp; информации&nbsp; с заданной позиции
экрана&nbsp; является&nbsp; функция&nbsp; TAB (X,Y),&nbsp; где&nbsp; параметры&nbsp; X,Y-задают
непосредственно координаты позиции экрана&nbsp; для&nbsp; вывода&nbsp; требуемой
информации.&nbsp; Функция&nbsp; TAB(X,Y)&nbsp; используется&nbsp; в списке переменных
оператора PRINT и осуществляет посылку&nbsp; курсора в указанное через
параметры&nbsp; место&nbsp; экрана.&nbsp; Следующий&nbsp; пример&nbsp; фрагмента программы
реализует&nbsp; электронное&nbsp; табло&nbsp; на экране, где&nbsp; в&nbsp; заданном&nbsp; месте
(пятая&nbsp; сверху&nbsp; строка, восемнадцатая&nbsp; слева&nbsp; позиция)&nbsp; пробегают
цифры от 1 до  1000.

            10 CLS
            20 FOR I=1 TO 1000
            30 PRINT TAB (18,5);I
            40 NEXT I

     Оператор 10 CLS осуществляет очистку&nbsp; экрана&nbsp; при выполнении
программы. 
     Функция TAB может также использоваться&nbsp; в&nbsp; обычной&nbsp; форме&nbsp; с
одним&nbsp; параметром&nbsp; TAB(X),&nbsp; где&nbsp; X&nbsp; -&nbsp; номер&nbsp; позиции&nbsp; в&nbsp; текущей
выводимой строке. Пример фрагмента программы:

            10 PRINT "01234567890123456789"
            20 FOR F=16 TO 17
            30 PRINT TAB (10); F; TAB (15); 2*F
            40 NEXT F
            &gt;RUN
            01234567890123456789
                       16     32 
                       17     34

     Оператор&nbsp;&nbsp; 10&nbsp;&nbsp; используется&nbsp;&nbsp; в&nbsp;&nbsp; данном&nbsp;&nbsp;&nbsp; фрагменте&nbsp;&nbsp; для
идентификации, с целью наглядности, номера позиции строки. 
     Необходимо&nbsp; отметить,&nbsp; что с помощью&nbsp; функции&nbsp; TAB(X),&nbsp; если
всречается в операторе PRINT несколько раз, можно изменить номера
адресуемых позиций в&nbsp; строке только в строну возрастания (как это
сделано в предшествующем примере - TAB(10), затем TAB(15) и т.д.)
Если в списке оператора PRINT встречается функция TAB(N), а после
нее TAB(M) при М&lt;N&nbsp; возврата&nbsp; курсора к предшествующим позициям в
текущей&nbsp;&nbsp;&nbsp; строке&nbsp;&nbsp; вывода&nbsp;&nbsp; не&nbsp;&nbsp; происходит&nbsp;&nbsp; и&nbsp;&nbsp; осуществляется
автоматический&nbsp; переход&nbsp; к&nbsp; следующей строке. Изменим оператор 30
предшествующего примера, поменяв местами номера позиций в функции
TAB(X) : 

                  30 PRINT TAB (15); F;TAB (10);2*F

     Тогда&nbsp; при&nbsp; выполнении&nbsp; измененного&nbsp; фрагмента&nbsp;&nbsp; на&nbsp;&nbsp; экране
появится выводимая информация в следующем виде:

       &gt;RUN 
       01234567890123456789
                      16
                 32
                      17
                 34

     Таким&nbsp; образом&nbsp; мы рассмотрели одно&nbsp; из&nbsp; средств&nbsp; управления
размещением информации на экране при выводе, реализуемое функцией
языка BASIC - TAB(X,Y). 
     Однако,&nbsp; часто&nbsp; бывает&nbsp; необходимо&nbsp; (удобно),&nbsp; например&nbsp; при
выводе значения следующей переменной списка, перемещать курсор по
экрану&nbsp; не&nbsp; в  фиксированные позиции,&nbsp; а&nbsp; на&nbsp; произвольное&nbsp; число
позиций&nbsp; (влево,&nbsp; вправо,&nbsp;&nbsp; вверх,&nbsp;&nbsp; вниз)&nbsp; относительно&nbsp; текущей
позиции. Мы знаем, что все символы, с которыми работает ПЭВМ и, в
часности,&nbsp;&nbsp; осуществляет&nbsp;&nbsp; их&nbsp;&nbsp;&nbsp; ввод-вывод,&nbsp;&nbsp; представляются&nbsp;&nbsp; в
оперативной памяти своими ASCII-кодами (см.п.3.2.2). Имеется ряд,
так&nbsp; называемых&nbsp; дисплейных&nbsp;&nbsp; ASCII-кодов,&nbsp;&nbsp; для&nbsp;&nbsp; которых&nbsp; вывод
соответствующих символов заключается&nbsp; в&nbsp; перемещении&nbsp; курсора&nbsp; на
одну&nbsp; позицию&nbsp; экрана&nbsp; влево,&nbsp; вправо,&nbsp; вверх,&nbsp; вниз.&nbsp; Вывод этих
символов&nbsp;&nbsp; полностью&nbsp; аналогичен&nbsp; перемещению&nbsp; читающего&nbsp; курсора
клавишами&nbsp;&nbsp; со&nbsp;&nbsp; стрелками&nbsp;&nbsp; в&nbsp; режиме&nbsp; экранного&nbsp; редактирования
(см.п.2.2). Приведем указанные ASCII-коды: 
       код  8-перемещение курсора на одну позицию влево; 	
       код  9-вправо;
       код 10-вниз;
       код 11-вверх.
     Вывод символов с указанными кодами осуществляется оператором
PRINT с использованием известной функции&nbsp; CHR&nbsp; (см.&nbsp; п.3.2 ). Так
например,&nbsp; перемещение курсора на одну позицию вправо и&nbsp; на&nbsp; одну
строку вниз осуществляется оператором 

                   PRINT CHR&curren;(9);CHR&curren;(10);  

     Обратим&nbsp; внимание,&nbsp; что в данном&nbsp; операторе&nbsp; для&nbsp; разделения
элементов списка и&nbsp; в&nbsp; конце списка применяется символ ; (не , ),
что&nbsp; запрещает соответственно при перемещении&nbsp; курсора&nbsp; и&nbsp; выводе
информации (например,&nbsp; в&nbsp; следующем оператора PRINT) переходить к
следующим полям строки (отменяет форматирование выводимых строк с
помощью полей). Если требуется&nbsp; переместить курсор в общем случае
на&nbsp; N&nbsp; позиций&nbsp; в одном&nbsp; из&nbsp; направлений,&nbsp; можно&nbsp; воспользоваться
языковой&nbsp;&nbsp; конструкцией&nbsp; оператора&nbsp; цикла.&nbsp;&nbsp; Так,&nbsp;&nbsp; например,&nbsp;&nbsp; в
результате выполнения фрагмента:

               10 FOR I=1 TO 25
               20 PRINT CHR&curren;(9);
               30 NEXT I

курсор будет перемещен на 25 позиций вправо.



        3.4  Языковые средства ввода информации с терминала

     Основным&nbsp; средством языка BASIC, используемым&nbsp; в&nbsp; программах
для ввода&nbsp; информации&nbsp; с&nbsp; терминала, является оператор INPUT. Как
известно, действие этого оператора заключается&nbsp; в выдаче на экран
символа "?" и переводе ПЭВМ в&nbsp; состояние&nbsp; ожидания&nbsp; терминального
ввода,&nbsp; завершающегося нажатием клавиши RETURN. Вводимые значения
при&nbsp; этом&nbsp;&nbsp; последовательно&nbsp; присваиваются&nbsp; переменным&nbsp; в&nbsp; списке
оператора INPUT.&nbsp; Запрос&nbsp; ввода&nbsp; может&nbsp; сопровождаться выдачей на
экран некоторого текстового сообщения, имеющего смысл&nbsp; вопроса, а
сами&nbsp;&nbsp;&nbsp; вводимые&nbsp;&nbsp; значения&nbsp;&nbsp; в&nbsp;&nbsp; диалоговых&nbsp;&nbsp; программах&nbsp;&nbsp; могут
интерпритироваться&nbsp;&nbsp; как&nbsp;&nbsp; ответ&nbsp;&nbsp; на&nbsp;&nbsp; этот&nbsp;&nbsp; вопрос.&nbsp; Текстовое
"сообщение-запрос"&nbsp;&nbsp;&nbsp; может&nbsp;&nbsp; быть&nbsp;&nbsp; выведено&nbsp;&nbsp; на&nbsp;&nbsp; экран&nbsp;&nbsp; либо
предшествуюшим&nbsp; оператору&nbsp; INPUT&nbsp; оператором&nbsp; PRINT,&nbsp; либо&nbsp; самим
оператором&nbsp;&nbsp; INPUT.&nbsp; Символьная&nbsp; строка,&nbsp; заключенная&nbsp; в&nbsp; двойные
кавычки,&nbsp; следующая в начале списка оператора INPUT, выводится им
на экран,&nbsp; и&nbsp; в той же строке ожидается ввод значений переменных.
Например, фрагмент запроса и&nbsp; ввода&nbsp; имени&nbsp; абонента&nbsp; может&nbsp; быть
реализован&nbsp;&nbsp; двумя&nbsp;&nbsp; полностью&nbsp; эквивалентными,&nbsp; с&nbsp; точки&nbsp; зрения
выполнения программы, способами:

             10 PRINT "Ваше имя: ";
             20 INPUT Name&curren;

или одним оператором

             10 INPUT "Ваше имя: "Name&curren;

    Исполнение&nbsp; фрагментов&nbsp; будет выглядеть на&nbsp; экране&nbsp; следующим
образом :

             &gt; RUN
             Ваше имя: Николай

     Вводимое&nbsp; имя&nbsp; (в&nbsp; данном&nbsp; случае&nbsp;&nbsp; Николай)&nbsp;&nbsp; присваивается
символьной переменной Name&curren;. Обратим внимание&nbsp; еще раз, что любой
ввод&nbsp; информации&nbsp; оператором&nbsp; INPUT&nbsp; завершается нажатием клавиши
RETURN. До этого момента такая строка может  быть  модифицирована
с использованием клавиши DELETE или&nbsp; отменена полностью с помощью
управляющего&nbsp; символа&nbsp; CTRL/U.&nbsp; В&nbsp; ряде случаев&nbsp; бывает&nbsp; полезной
возможность&nbsp; немедленного&nbsp; осуществления программного ввода путем
нажатия произвольной клавиши&nbsp; (без&nbsp; последующего&nbsp; нажатия клавиши
RETURN). Такой ввод используется в большинстве&nbsp; игровых программ,
когда&nbsp;&nbsp; требуется&nbsp;&nbsp; быстрая&nbsp;&nbsp; реакция&nbsp; на&nbsp; управление&nbsp; событиями,
происходящими на экране дисплея, со стороны пользователя. 
     В языке BASIC для осуществления&nbsp; немедленного&nbsp; ввода символа
путем&nbsp;&nbsp;&nbsp; нажатия&nbsp;&nbsp; произвольной&nbsp;&nbsp; клавиши&nbsp;&nbsp; используются&nbsp;&nbsp; четыре
специальные функции: GET, GET&curren;, INKEY,INKEY&curren;. Поскольку при вводе
с&nbsp; помощью&nbsp; этих функций символ присваивается одной из переменных
программы (т.е. может&nbsp; быть&nbsp; в дальнейшем проанализираван), такой
способ ввода также удобен при разветвлении программ пользователем
путем ответа на вопрос одним&nbsp; символом,&nbsp; например&nbsp; Д(да), Н(нет),
Y(yes), N(no) и т.д.
     Рассмотрим подробнее указанные функции. Все&nbsp; они&nbsp; могут быть
использованы в правой части оператора присваивания. В левой части
указывается одна из переменных программы, причем символьная - для
функций GET&curren;, INKEY&curren; и соответственно - числовая для функций GET,
INKEY.&nbsp; Действие функций GET&curren; и GET, INKEY&curren;&nbsp; и&nbsp; INKEY&nbsp; одинаково,
только в&nbsp; первом&nbsp; случае они возвращают символ, а во втором - его
ASCII-код.
     Функция&nbsp; GET&nbsp; и GET&curren; переводит&nbsp; ПЭВМ&nbsp; в&nbsp; состояние&nbsp; ожидания
терминального ввода (переход&nbsp; к&nbsp; следующему&nbsp; оператору&nbsp; программы
будет&nbsp; осуществлен&nbsp; только&nbsp; после&nbsp; нажатия произвольной клавиши).
     Примеры операторов:

         А=GET      (А получает значение кода введенного символа)
         A&curren;=GET&curren;    (А&curren; - введенный символ).

     Основное&nbsp;&nbsp; назначение&nbsp;&nbsp; функций&nbsp; GET&nbsp; и&nbsp;&nbsp; GET&curren;&nbsp;&nbsp; состоит&nbsp;&nbsp; в
приостановке&nbsp; вывода&nbsp; информации&nbsp; на экран&nbsp; дисплея.&nbsp; Это&nbsp; бывает
необходимо,когда вся выводимая подряд&nbsp; информация&nbsp; не&nbsp; может быть
размещена на экране. Тогда между операторами вывода&nbsp; в&nbsp; программу
включается оператор присваивания функции GET или GET&curren; и переход к
следующему&nbsp; кадру&nbsp; экрана&nbsp; происходит после нажатия пользователем
программы произвольной клавиши.
     Функции INKEY и INKEY&curren; вызывают&nbsp; ожидание&nbsp; ввода&nbsp; символа&nbsp; в
течении&nbsp; заданного&nbsp; интервала&nbsp; времени&nbsp; и&nbsp; осуществляют переход к
следующему оператору либо сразу после нажатия&nbsp; клавиши,&nbsp; либо&nbsp; по
истечении&nbsp;&nbsp;&nbsp; заданного&nbsp;&nbsp;&nbsp; временного&nbsp;&nbsp;&nbsp; интервала.&nbsp;&nbsp;&nbsp; Общий&nbsp;&nbsp; вид
соответстующих операторов присваивания:

                 А=INKEY(n)
          или    A&curren;=INKEY&curren;(n)     ,
где n - временной интервал ожидания ввода в сотых долях секунды.
     По&nbsp; истечении&nbsp; временного&nbsp; интервала числовая&nbsp; переменная&nbsp; в
левой&nbsp;&nbsp; части&nbsp; (А)&nbsp; получает&nbsp;&nbsp; значение-1,&nbsp;&nbsp; а&nbsp;&nbsp; символьная-пусто
(отсутствие&nbsp; значения&nbsp; символьной&nbsp; переменной).&nbsp;&nbsp; Символ&nbsp; "пусто"
изображается&nbsp; ""&nbsp; (пара&nbsp; следующих&nbsp;&nbsp; подряд&nbsp;&nbsp; двойных&nbsp;&nbsp; кавычек). 
Например, оператор 
                 10 В&curren;=INKEY&curren;(200)
     приводит к ожиданию ввода в течении двух секунд. Если в этот
временной отрезок будет нажата клавиша, например Y, то В&curren; получит
значение "Y" и сразу произойдет&nbsp; переход&nbsp; к&nbsp; следующему оператору
программы,&nbsp; иначе&nbsp; по&nbsp; истечении&nbsp; двух&nbsp; секунд В&curren; будет присвоено
значение&nbsp; "".&nbsp; Анализ&nbsp; значения переменной, присвоеного функциями
INKEY или INKEY&curren; позволяет учесть в программе не только введенный
символ (нажатую клавишу), но&nbsp; и&nbsp; проконтролировать,&nbsp; что она была
нажата&nbsp; в&nbsp; течение&nbsp; заданного&nbsp; временного интервала, т.е. оценить
реакцию пользователя (например, время принятия решения).


                 3.5   Управляющие структуры

                 3.5.1 Общие положения

     К&nbsp; основным управляющим структурам языка&nbsp; BASIC&nbsp; (средствам,
определяющим последовательность&nbsp; выполнения операторов программы)
относятся&nbsp; известные&nbsp; операторы:&nbsp; перехода&nbsp; GOTO&nbsp; и&nbsp; вычисляемого
перехода ON GOTO,&nbsp; условный оператор IF...THEN, конструкция цикла
FOR...NEXT, оператор перехода GOSUB&nbsp; и&nbsp; вычисляемого&nbsp; перехода ON
GOSUB к подпрограмме.
     Все&nbsp; перечисленные&nbsp; средства&nbsp; содержатся&nbsp; в&nbsp;  рассмариваемой
версии&nbsp; языка.&nbsp; Однако&nbsp;  имеется, во-первых, целый ряд расширений
предоставляемых&nbsp;&nbsp;&nbsp;&nbsp; возможностей,&nbsp;&nbsp;&nbsp; а&nbsp;&nbsp;&nbsp; во-вторых,&nbsp; &nbsp;&nbsp; вводится
дополнительная структура REPEAT...UNTIL, широко распространненная
в&nbsp;&nbsp; ряде&nbsp;&nbsp; современных&nbsp; языков&nbsp; прогаммирования&nbsp; высокого&nbsp; уровня
(например, 'PASCAL','C' и др.)
     Рассмотрим сначала расширенные возможности известных средств
языка.

                 3.5.2 Оператор GO TO

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

                  GOTO label
                  GOTO (start*55+14)

     Значение&nbsp; переменной,&nbsp; и результат арифметического выражения
должны быть целочисленными.&nbsp; Они интерпритируются оператором GOTO
как номер строки перехода в данной программе. 
     Оператор&nbsp;&nbsp; GOTO,&nbsp; используемый&nbsp; в&nbsp; режиме&nbsp; непосредственного
выполнения (в качестве команды оператора), позволяет осуществлять
запуск&nbsp; программы,&nbsp; находящейся&nbsp; в оперативной памяти, с текущими
значениями&nbsp; переменных.&nbsp; Пусть&nbsp; в&nbsp; оперативной&nbsp; памяти&nbsp; находится
некоторая программа, при выполнении&nbsp; которой&nbsp; обнаружены&nbsp; ошибки.
Используя&nbsp; команду&nbsp; GOTO&nbsp; можно&nbsp; проследить&nbsp; за&nbsp; ходом выполнения
отдельных&nbsp;&nbsp; (произвольных)&nbsp;&nbsp; участков&nbsp; программы&nbsp;  при&nbsp; известных
значениях переменных, т.е. произвести отладку. Например, команда 
                   GOTO 1200
инициирует&nbsp; выполнение&nbsp; операторов текущий программы&nbsp; начиная&nbsp; со
строки&nbsp; 1200. Отметим,&nbsp; что&nbsp; современная&nbsp; методология&nbsp; программи-
рования, базирующаяся&nbsp; на&nbsp; структурном&nbsp; подходе&nbsp; к&nbsp; разработке&nbsp; и
написанию&nbsp; программ,&nbsp; не&nbsp; рекомендует&nbsp; исползовать&nbsp; оператор GOTO
вообще и особенно в больших программах. Объясняется  это тем, что
программа,&nbsp; содержащая&nbsp; большое количество переходов по оператору
GOTO&nbsp; имеет&nbsp; текст,&nbsp;&nbsp; практически&nbsp;&nbsp; не&nbsp; соответствующий&nbsp; последо-
вательности&nbsp; выполнения.&nbsp; Такая&nbsp;&nbsp; программа&nbsp;&nbsp; крайне&nbsp; трудна&nbsp; для
понимания, а значит и для модернизации или исправления.
     Однако,&nbsp; некоторые&nbsp; языки программирования  (например, очень
распространенный&nbsp; язык&nbsp; FORTRAN&nbsp; 4)&nbsp; не&nbsp; позваляют&nbsp; обойтись&nbsp; без
оператора GOTO даже&nbsp; при организации элементарных разветвлений. В
этом смысле с удовлетворением можно отметить, что рассматриваемая
версия&nbsp; языка&nbsp; BASIC&nbsp; содержит&nbsp;&nbsp;   полный&nbsp;   набор&nbsp;   управляющих 
структур&nbsp; для&nbsp;  того,&nbsp;  чтобы&nbsp; можно&nbsp; было&nbsp; обойтись&nbsp; вообще&nbsp; без
оператора GOTO и составлять&nbsp; программы&nbsp; в&nbsp; соответствии&nbsp; с&nbsp; самой
современной&nbsp; технологией.&nbsp; Можно сказать, что язык BASIC в данном
случае&nbsp;&nbsp; является&nbsp;&nbsp; языком&nbsp;&nbsp; структурного&nbsp;&nbsp; программирования.&nbsp;&nbsp; В
заключение - изящный&nbsp; пример&nbsp; использования оператора GOTO в виде
фрагмента&nbsp; программы,&nbsp; немедленно&nbsp; отображающей&nbsp; на&nbsp;&nbsp; экране&nbsp; код
введенного символа для любой нажимаемой клавиши.

                  10 PRINT GET
                  20 GOTO 10


                 3.5.3 Операторы ON...GOTO, ON...GOSUB

     Как&nbsp; известно,&nbsp; действие&nbsp; операторов&nbsp; вычисляемых&nbsp; переходов
ON...GOTO,&nbsp;&nbsp; ON...GOSUB&nbsp;&nbsp; заключается&nbsp;&nbsp; в&nbsp;&nbsp; передаче&nbsp;&nbsp; управления
определенной&nbsp; части&nbsp; программы &nbsp; в&nbsp; зависимости&nbsp; от значения, так
называемой,&nbsp; управляющей&nbsp; переменной.&nbsp; В&nbsp; данной&nbsp; версии&nbsp; Бейсика
операторы&nbsp;&nbsp; ON...GOTO&nbsp;&nbsp; и&nbsp;&nbsp; ON...GOSUB&nbsp;&nbsp; содержат&nbsp; дополнительную
возможность&nbsp; указания&nbsp; последовательности действий в случае,когда
значение&nbsp; управляющей&nbsp; переменной&nbsp;&nbsp; находится&nbsp;&nbsp;  вне&nbsp; допустимого
диапозона значений, т.е.&nbsp; превосходит максимально возможный номер
элемента в списках оперторов&nbsp; ON...GOTO,&nbsp; ON...GOSUB. Общая форма
оперторов имеет вид :

ON&lt;числ.перем.&gt; GOTO&lt;числ.выраж&gt;[,&lt;числ.выраж&gt;] [ELSE&lt;оператор&gt;]
ON&lt;числ.перем.&gt; GOSUB&lt;числ.выраж&gt;[,&lt;числ.выраж&gt;] [ELSE&lt;оператор&gt;]

     Например, оператор
        ON F% GOTO 100,210,350 ELSE GOTO 1000  осуществит переход
на строку программы номер 1000, если значения переменной F% будет
любым, кроме 1,2 или 3.


                 3.5.4 Оператор IF...THEN...ELSE

     В отличие от известного условного&nbsp; оператора&nbsp; IF конструкция
оператора&nbsp; IF...THEN...ELSE&nbsp;  является&nbsp; более&nbsp; общей&nbsp; и позволяет
легко&nbsp;&nbsp; реализовать&nbsp; одну&nbsp; из&nbsp; основных&nbsp; элементарных&nbsp; логических
структур - "развилку" без использования оператора GOTO.

             10 A&curren;=GET&curren;
             20 IF A&curren;="&"THEN PRINT "Верно" ELSE
                PRINT"Не правильно"

     Тот же фрагмент с использованием&nbsp; усеченной&nbsp; формы оператора
IF&nbsp; (без&nbsp; ELSE&nbsp; в привычной версии языка&nbsp; BASIC)&nbsp; выглядит&nbsp; менее
изящно: 
             10 A&curren;=GET&curren;
             20 IF A&curren;="&" THEN GOTO 50
             30 PRINT "Не правильно" 
             40 GOTO 60
             50 PRINT "Верно"
             60 ..........

     Забегая&nbsp;&nbsp; вперед,&nbsp; подчеркнем,&nbsp; что&nbsp; применение&nbsp; конструкции
IF...THEN...ELSE&nbsp;&nbsp;&nbsp;&nbsp; является&nbsp;&nbsp;&nbsp;&nbsp; наиболее&nbsp;&nbsp;&nbsp;&nbsp; эффективным&nbsp;&nbsp;&nbsp; для
структурирования&nbsp; программ,&nbsp; особенно при использовании механизма
процедур (см. п.&nbsp; 3.6),&nbsp; придает программам максимально возможную
наглядность,&nbsp;&nbsp; а&nbsp;&nbsp; следовательно,&nbsp; существенно&nbsp; упрощет&nbsp; процессы
написания отладки и модернизации.


                 3.5.5 Конструкция REPEAT...UNTIL.

     Данная&nbsp; конструкция&nbsp; представляет&nbsp; собой некоторое обобщение 
конструкции&nbsp; цикла&nbsp; FOR...NEXT.&nbsp; Она&nbsp;&nbsp; также&nbsp;&nbsp; предназначена&nbsp; для
организации&nbsp; многократного&nbsp; (циклического)&nbsp; повторения&nbsp; фрагмента
программы, включающего последовательность строк между операторами
REPEAT&nbsp; (открывает&nbsp; цикл)&nbsp; и&nbsp; UNTIL&nbsp; (ограничевает&nbsp; цикл&nbsp; снизу).
Заметим,&nbsp; что&nbsp; ключевые слова конструкции REPEAT и UNTIL являются
разными&nbsp; (могут&nbsp; иметь&nbsp;&nbsp; различные,&nbsp;&nbsp; самостоятельные,&nbsp; номера&nbsp; в
программе) логически связанными&nbsp; операторами&nbsp; языка&nbsp; BASIC,&nbsp; т.е.
наличие&nbsp; оператора&nbsp; REPEAT&nbsp; предполагает&nbsp; обязательное дальнейшие
присутствие в программе оператора  UNTIL. Общая форма конструкции
имеет вид 

                   100  REPEAT 
                        произвольное колич.
                        операторов         
                  100+м UNTIL логич. выр.

где логич. выр. - произвольное логическое выражение,
представляющее собой условие окончания цикла.
     Выполнение&nbsp; последовательности&nbsp; строк программы, заключенной
между операторами REPEAT&nbsp; и&nbsp; UNTIL, будет повторяться до тех пор,
пока указанное логическое выражение не&nbsp; станет истинно. Мы видим,
что&nbsp; конструкция&nbsp; цикла&nbsp; REPEAT...UNTIL является более&nbsp; общей&nbsp; по
отношению&nbsp; к&nbsp; конструкции FOR...NEXT,&nbsp; для&nbsp; которой&nbsp; имеет&nbsp; место
единственное условие окончания&nbsp; цикла&nbsp; -&nbsp; достижение&nbsp; управляющей
переменной&nbsp;&nbsp; заданного&nbsp;&nbsp; значения.&nbsp;&nbsp; Наряду&nbsp; с&nbsp; этим,&nbsp; отсутствие
управляющей&nbsp;&nbsp; переменной&nbsp;&nbsp; вообще&nbsp; в&nbsp; конструкции&nbsp; REPEAT...UNTIL
вызывает&nbsp; необходимость&nbsp; предусматривать&nbsp; изменение&nbsp; внутри цикла
значений&nbsp; переменных, входящих в логическое&nbsp; выражение&nbsp; оператора
UNTIL.&nbsp; В&nbsp; противном&nbsp; случае,&nbsp; может&nbsp; оказаться,&nbsp; что&nbsp; логическое
выражение&nbsp;&nbsp; будет&nbsp;&nbsp;&nbsp; оставаться&nbsp;&nbsp;&nbsp; неизменненым&nbsp;&nbsp; (иметь&nbsp;&nbsp; всегда
значение-ложь) и цикл станет бесконечным.
     Наглядным&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; примером&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; эффективного&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; использования
рассматриваемой&nbsp;&nbsp; конструкции&nbsp; является&nbsp; запрос&nbsp; ввода&nbsp; заданного
(конкретного)&nbsp; символа,&nbsp; смысл которого может состоять, скажем, в
проверке знания расположения&nbsp; указанной&nbsp; клавиши и способа ввода.
Пусть&nbsp;&nbsp; это&nbsp; будет&nbsp; символ&nbsp; &.&nbsp;&nbsp; Тогда&nbsp;&nbsp; нижеследующий&nbsp;&nbsp; фрагмент
осуществляет такой запрос и подсчитывает время реакции:
              10 Z&curren;="&"
              20 PRINT "Введите символ &";
              30 T=TIME
              40 REPEAT UNTIL GET&curren;=Z&curren;
              50 PRINT "Вы затратили ";(TIME-T)/100;" секунд"
     Строка 40 будет выполняться (зацикливаться) до тех пор, пока
пользователь программы не введет символ &.
NT "Введите символ &";
              30 T=TIME
              40 REPEAT UNTIL G─PL63
</pre>
[an error occurred while processing this directive]