РЯП скрипт — учебник

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

Глава 0. Знакомство и установка

РЯП скрипт — язык программирования, в котором команды пишутся по-русски. Программа на РЯП — обычный текстовый файл с расширением .ряпс. Специальная программа — компилятор ryap.exe — превращает её в веб-страницу, которую открывает любой браузер: получаются программы с окнами, кнопками и даже игры с картинками.

Работать можно двумя способами:

• в этом учебнике — всё запускается прямо на странице, устанавливать ничего не нужно;
• по-настоящему — как у программистов: файл .ряпс в редакторе Sublime Text, одна клавиша — и программа открывается в браузере. Об этом — ниже.

Установка: приложение РЯПС2.7

1. Распакуйте архив РЯПС2.7-установка.zip в любую папку.
2. Запустите Установить.bat. Он сам скопирует приложение, добавит команду ryap.exe, подключит Sublime Text, создаст ярлыки и свяжет файлы .ряпс и .ряп. Права администратора не нужны.
3. Установите редактор Sublime Text: зайдите на сайт sublimetext.com, нажмите Download, запустите скачанный установщик (дальше — Далее, Далее, Готово).
4. Откройте файл примера (папка примеры) двойным щелчком — он откроется в Sublime с подсветкой. Нажмите Ctrl+B — программа скомпилируется и откроется в браузере. Ctrl+Shift+B — выбрать вариант «РЯПС» (получить файл .js).

Проверка установки: нажмите Win+R, введите cmd, Enter, в чёрном окне наберите ryap.exe -h — должна появиться справка по командам. Если появилась — всё работает.

Задания и проверки

В конце каждой главы — задания. В каждом задании: условие, форматы ввода и вывода, таблица «Например» с открытыми тестами и редактор кода.

Кнопка «Проверить» прогоняет вашу программу на открытых тестах (в таблице видно: Ввод → Ожидалось → Получил) и на скрытых тестах — по ним видно только ✓ или ✗, а вверху считается процент правильных решений. Скрытые тесты проверяют то, чего нет в примерах: другие числа, другие имена. Задание выполнено, когда процент равен 100%.

Полезно знать:

• строки во время проверки подставляются в вашу программу автоматически — ничего вводить не нужно;
• решения заданий сохраняются сами (открыли учебник снова — решения на месте);
• отменить/вернуть правки: Ctrl+Z и Ctrl+Shift+Z или кнопки ↶ ↷ над редактором.

Если что-то не работает

• «ryap.exe не является внутренней или внешней командой» — вы вводите команду в окне, открытом ДО установки. Закройте окно и откройте новое, либо запустите Установить.bat ещё раз.
• «Windows защитил ваш компьютер» при запуске установщика — нажмите «Подробнее» → «Выполнить в любом случае». Приложение работает локально, без интернета.
• «Не найден src/keywords.csv» — файлы приложения повреждены или перенесены. Запустите Установить.bat из распакованного архива заново.
• Браузер не открылся сам — найдите файл .html рядом с вашей программой и откройте его двойным щелчком.
• Антивирус ругается на ryap.exe — добавьте папку РЯПС2.7 в исключения антивируса: компилятор не выходит в интернет.
• Ошибки в самой программе — красная панель в браузере и предупреждения компилятора подскажут, что не так. Этому посвящена Глава 6.

Дальше — Глава 1: ваша первая программа. В учебнике она запускается прямо здесь, а после установки те же примеры будут работать и в Sublime.

Глава 1. Первая программа

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

Этот учебник живой: каждый пример можно запустить прямо здесь — кнопкой «Запустить» под редактором. Результат появится в чёрной панели ниже.

Шаг 1. Команда «окно»

Самая простая команда — окно: она показывает на экране окно с вашим текстом. Текст пишется в кавычках, после команды — скобки:

Попробуйте изменить текст в кавычках и запустить снова — в окне появится ваше сообщение. Текст в кавычках называется строкой.

Шаг 2. Команда «печать»

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

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

Шаг 3. Переменные: программа запоминает

Программа может запомнить значение и дать ему имя — это называется переменной. А команда ЗОП задаёт пользователю вопрос и запоминает его ответ:

Что здесь произошло:

• ЗОП("Как тебя зовут?") — задали вопрос, ответ записался в переменную имя;
• знак + склеивает строки в одну длинную;
• окно показало приветствие вместе с ответом.

При запуске браузер покажет стандартное окно ввода — ответ напечатает человек на клавиатуре.

Задания к главе

Напишите решение в редакторе и нажмите «Проверить». Программа запустится прямо здесь, и проверки отметят результат. Застряли — откройте подсказку, потом решение.

окно("Привет, мир!")

печать("Меня зовут РЯП")
печать("Я умею программировать")

пер имя = ЗОП("Как тебя зовут?")
окно("Привет, " + имя + "!")

пер ответ = 6 * 7
печать(ответ)

Дальше — Глава 2: числа и арифметика. Справка по всем словам — в СПРАВКА.html.

Глава 2. Числа и арифметика

Компьютер изначально был создан как очень быстрый калькулятор. Числа пишутся без кавычек — кавычки только для текста. Сравните: печать("2+2") напечатает 2+2, а печать(2+2) напечатает 4.

Шаг 1. Числа с клавиатуры и четыре действия

Считать число с клавиатуры помогает команда ЦЗОП (цифровое значение от пользователя): пер возраст = ЦЗОП("Сколько тебе лет?") запомнит ответ как число, с которым можно считать. Четыре действия:

Работают +, -, * (умножение), / (деление). Скобки, как в математике, меняют порядок:

Шаг 2. Остаток от деления

В школе вы делили с остатком: 17 конфет на 5 друзей — каждому по 3, и 2 остаётся. За это отвечает команда остаток от деления на:

Если остаток равен 0 — число делится нацело. Так проверяют чётность, кратность и «каждый третий шаг».

Шаг 3. Округление

Деление даёт дроби: 7 / 2 = 3.5. Команды округления:

• округлить — по правилам математики (3.5 → 4, 3.2 → 3);
• целое снизу — всегда вниз (3.9 → 3);
• целое сверху — всегда вверх (3.1 → 4).

Внимание: считывается всё выражение в скобках — пишите целое снизу(7 / 2), чтобы округлить именно результат деления.

Шаг 4. Переменная-счётчик

Часто нужно увеличить значение: взять старое, прибавить один, записать обратно. Компьютер выполняет х = х + 1 именно так:

Этот приём — основа счёта в играх: очки, жизни, уровни растут именно так.

Задания к главе

пер часы = ЦЗОП("Сколько часов?")
пер минуты = ЦЗОП("Сколько минут?")
пер секунды = ЦЗОП("Сколько секунд?")
печать(часы * 60 * 60 + минуты * 60 + секунды)

пер цена_ручки = ЦЗОП("Цена ручки?")
пер ручки = ЦЗОП("Сколько ручек?")
пер цена_тетради = ЦЗОП("Цена тетради?")
пер тетради = ЦЗОП("Сколько тетрадей?")
печать(цена_ручки * ручки + цена_тетради * тетради)

пер конфеты = ЦЗОП("Сколько конфет?")
пер друзья = ЦЗОП("Сколько друзей?")
печать(конфеты остаток от деления на друзья)

пер всего = ЦЗОП("Сколько минут?")
пер часы = целое снизу(всего / 60)
пер минуты = всего остаток от деления на 60
печать(часы + " ч " + минуты + " мин")

Дальше — Глава 3: условия «если — иначе», где программа начинает принимать решения.

Глава 3. Условия: если — иначе

До сих пор команды выполнялись одна за другой, сверху вниз. Условия позволяют программе принимать решения: выполнить одни команды, если условие верно, и другие — если нет.

Шаг 1. Если — то — конец — иначе

Команда если проверяет условие. Если оно верно, выполняются команды до слова конец; слово иначе — это «в противном случае»:

Как читать: «если число больше 100, то — „Много!“, иначе — „Немного“». Каждая ветка заканчивается своим словом конец — и ветка перед иначе не исключение.

Шаг 2. Сравнения

Сравнивать можно и числа, и строки: если имя равно "Аня" то …

Шаг 3. Иначе если: выбор из нескольких

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

Шаг 4. И, или, не

Условия объединяются: и — верны оба, или — хотя бы одно, не — наоборот:

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

Задания к главе

пер число = ЦЗОП("Введите число")
если число больше 0 то
	печать("плюс")
конец
иначе если число меньше 0 то
	печать("минус")
конец
иначе
	печать("ноль")
конец

пер число = ЦЗОП("Введите число")
если число остаток от деления на 2 равно 0 то
	печать("чётное")
конец
иначе
	печать("нечётное")
конец

пер год = ЦЗОП("Введите год")
если (год остаток от деления на 4 равно 0 и год остаток от деления на 100 не равно 0) или год остаток от деления на 400 равно 0 то
	печать("да")
конец
иначе
	печать("нет")
конец

пер возраст = ЦЗОП("Сколько лет?")
пер последняя = возраст остаток от деления на 10
если возраст большеравно 11 и возраст меньшеравно 14 то
	печать("Вам " + возраст + " лет")
конец
иначе если последняя равно 1 то
	печать("Вам " + возраст + " год")
конец
иначе если последняя большеравно 2 и последняя меньшеравно 4 то
	печать("Вам " + возраст + " года")
конец
иначе
	печать("Вам " + возраст + " лет")
конец

пер а = ЦЗОП("Первый отрезок")
пер б = ЦЗОП("Второй отрезок")
пер в = ЦЗОП("Третий отрезок")
если а меньше б + в и б меньше а + в и в меньше а + б то
	печать("да")
конец
иначе
	печать("нет")
конец

пер а = ЦЗОП("Первое число")
пер б = ЦЗОП("Второе число")
пер в = ЦЗОП("Третье число")
если а больше б то
	пер т = а
	а = б
	б = т
конец
если б больше в то
	пер т = б
	б = в
	в = т
конец
если а больше б то
	пер т = а
	а = б
	б = т
конец
печать(а + " " + б + " " + в)

Дальше — Глава 4: циклы. Компьютер сможет повторять команды за вас — хоть миллион раз.

Глава 4. Циклы: повторяем команды

Печатать одно и то же сто раз руками — мучение. Циклы говорят компьютеру: «повтори эти команды столько-то раз» или «повторяй, пока условие верно».

Шаг 1. Цикл со счётчиком

запустить цикл 5 раза то … конец повторяет команды 5 раз. Внутри цикла доступна переменная счетчик — она идёт по значениям 0, 1, 2, 3, 4:

Слова-метки: раза, раз, разов — выбирайте какое нравится.

Шаг 2. Счётчиком может быть выражение

Вместо числа можно написать любое выражение — цикл посчитает сам:

Часто счётчик нужен с единицы, а он идёт с нуля — тогда помогает (счетчик + 1).

Шаг 3. Накопление: копим ответ

Главный приём главы: переменная-накопитель. Перед циклом в неё кладут ноль, а в цикле прибавляют:

Так считают суммы, очки в играх, итоги чека.

Шаг 4. Цикл «пока» и выход из цикла

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

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

Задания к главе

пер слово = ЗОП("Какое слово?")
пер н = ЦЗОП("Сколько раз?")
запустить цикл н раза то
	печать((счетчик + 1) + ") " + слово)
конец

пер н = ЦЗОП("Введите число")
запустить цикл 9 раза то
	печать(н + " x " + (счетчик + 1) + " = " + н * (счетчик + 1))
конец

пер а = ЦЗОП("От какого числа?")
пер б = ЦЗОП("До какого числа?")
пер сумма = 0
запустить цикл (б - а + 1) раза то
	сумма = сумма + а + счетчик
конец
печать(сумма)

пер н = ЦЗОП("Введите число")
пер п = 1
пока п меньшеравно н то
	п = п * 2
конец
печать(п)

пер н = ЦЗОП("Введите число")
пер простое = "да"
если н меньше 2 то
	простое = "нет"
конец
пер д = 2
пока д меньше н то
	если н остаток от деления на д равно 0 то
		простое = "нет"
	конец
	д = д + 1
конец
печать(простое)

Дальше — Глава 5: типы значений. Строки и числа — разные вещи, и JavaScript умеет превращать одно в другое.

Глава 5. Типы значений: строки и числа

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

Шаг 1. Строка или число?

Запись в кавычках — строка (просто текст), без кавычек — число (с ним можно считать). Одинаковые цифры — разное поведение:

"2" + "2" — склейка: «22». 2 + 2 — сложение: 4. Помните: ЗОП приносит строку, ЦЗОП — число.

Шаг 2. Плюс хитрый, минус честный

Если в сложении участвует хотя бы одна строка — плюс склеивает. А вот минус, умножение и деление превращают строку в число и считают честно:

Это и есть жонглирование типами: JavaScript сам превращает значения, когда ему нужно. Удобно — но легко ошибиться.

Шаг 3. Превращения: из строки в число

Превратить строку в число помогает команда преобразовать строку в число (после неё ставьте пробел или скобку). Узнать тип значения — тип данных:

Шаг 4. Цифры числа: мост к олимпиадным задачам

Самая простая задача о цифрах решается без строк: последняя цифра числа — это н остаток от деления на 10; отрезать последнюю цифру — целое снизу(н / 10):

Эта пара приёмов в цикле «пока» умеет разбирать число на цифры — на ней построены классические олимпиадные задачи: сумма цифр, перевёртыш, палиндром. Они ждут вас в заданиях.

Задания к главе

пер н = ЗОП("Введите число")
печать(преобразовать строку в число н * 2)

пер н = ЦЗОП("Первое число")
пер м = ЦЗОП("Второе число")
печать("" + н + м)
печать(н + м)

пер н = ЦЗОП("Введите число")
пер сумма = 0
пока н больше 0 то
	сумма = сумма + н остаток от деления на 10
	н = целое снизу(н / 10)
конец
печать(сумма)

пер н = ЦЗОП("Введите число")
пер первая = н
пока первая больше 9 то
	первая = целое снизу(первая / 10)
конец
печать(первая)
печать(н остаток от деления на 10)

пер н = ЦЗОП("Введите число")
пер р = 0
пока н больше 0 то
	р = р * 10 + н остаток от деления на 10
	н = целое снизу(н / 10)
конец
печать(р)

пер н = ЦЗОП("Введите число")
пер р = 0
пер копия = н
пока копия больше 0 то
	р = р * 10 + копия остаток от деления на 10
	копия = целое снизу(копия / 10)
конец
если р равно н то
	печать("да")
конец
иначе
	печать("нет")
конец

Дальше — Глава 6: проверка ввода. Программа научится замечать пустой ответ и защищаться от ошибок.

Глава 6. Проверка ввода: пустой ответ и мусор

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

Шаг 1. Пустой ответ и длина строки

Если нажать «ОК», ничего не написав, ЗОП вернёт пустую строку — в ней нет ни одного символа. Сколько символов в строке, считает команда длина:

Теперь защитим приветствие: пустой ответ встречаем отдельной фразой

Запустите демо ещё раз и сотрите ответ в открывшемся окне — сработает первая ветка. Так и проверяют ввод: сначала «если ответ плохой», потом «иначе — работаем дальше».

Шаг 2. «Не число»: мусор в ЦЗОП

ЦЗОП превращает ответ в число. Но из слова «привет» числа не получится — получится особое значение «не число». У него странное свойство: оно не равно даже самому себе. Поэтому проверка н не равно н верна только тогда, когда пользователь ввёл мусор:

Запустите демо и введите сначала 5, потом привет — увидите обе ветки.

А пустой ответ ЦЗОП превращает в 0 — ещё одна причина проверять, что ввёл человек.

Шаг 3. Готовая проверка: проверка числа

То же самое умеет готовая команда проверка числа. Записывается как обычная команда — со скобками, которые пишете вы: проверка числа(н). Верна для настоящего числа, неверна для мусора:

Все проверки главы — в одной таблице:

Шаг 4. Спрашиваем до правильного ответа

Цикл пока плюс проверка — и вопрос повторяется сам, пока ответ не станет нормальным. Внутри цикла обязательно переспросите — иначе цикл станет вечным:

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

Задания к главе

пер имя = ЗОП("Как тебя зовут?")
если имя длина равно 0 то
	печать("Привет, незнакомец!")
конец
иначе
	печать("Привет, " + имя + "!")
конец

пер н = ЦЗОП("Введите число")
если н не равно н то
	печать("не число")
конец
иначе
	печать("число")
конец

пер имя = ЗОП("Как тебя зовут?")
пока имя длина равно 0 то
	имя = ЗОП("Пусто! Как тебя зовут?")
конец
печать("Привет, " + имя + "!")

пер н = ЦЗОП("Введите число")
пока н не равно н то
	н = ЦЗОП("Это не число! Попробуйте ещё раз")
конец
печать("Принято: " + н)

пер возраст = ЦЗОП("Сколько вам лет?")
пока возраст не равно возраст или возраст меньше 0 или возраст больше 150 то
	возраст = ЦЗОП("Так не бывает! Сколько вам лет?")
конец
печать("Возраст принят: " + возраст)

пер сумма = 0
пер слово = ЗОП("Введите число или стоп")
пока слово не равно "стоп" то
	сумма = сумма + преобразовать строку в число слово
	слово = ЗОП("Ещё число или стоп")
конец
печать(сумма)

Дальше — Глава 7: случайность. Компьютер придумает случайное число — и мы построим игру «Угадай число».

Глава 7. Функции: свои команды

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

Шаг 1. Своя команда

Объявление функции: слово функция, имя, принимает аргументы, имя аргумента, начало функции, команды, конец функции. После объявления её вызывают как обычную команду — по имени со скобками:

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

Шаг 2. Несколько аргументов и «вернуть»

Аргументов может быть несколько — они перечисляются через запятую. Чаще всего функция не просто печатает, а вычисляет и отдаёт результат командой вернуть:

После вернуть функция заканчивает работу: что бы ни шло дальше внутри неё, до этого уже не дойдёт. А сам вызов сумма(10, 5) — как будто на его место встало готовое число 15.

Вызывать функцию можно и до её объявления — переводчик сам разберётся.

Шаг 3. Стрелочные функции

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

Для функции с длинным телом есть «безымянная» запись: пер ф = безимянная функция н начало функции … конец функции. Тот же смысл, но тело — любые команды.

Шаг 4. Функция вызывает себя

Функции разрешено вызывать сами себя — это называется рекурсией. Классика: факториал. Факт: н! = 1 × 2 × … × н. Рекурсивно: «факториал н — это н, умноженный на факториал (н−1)», а «факториал 1 — это 1»:

Без стоп-условия («меньше или равно 1») вызовы никогда бы не закончились — как цикл без изменения переменной.

Задания к главе

функция приветствует принимает аргументы имя начало функции
	печать("Привет, " + имя + "!")
конец функции
пер имя = ЗОП("Как тебя зовут?")
приветствует(имя)

функция площадь принимает аргументы а, б начало функции
	вернуть а * б
конец функции
пер а = ЦЗОП("Ширина?")
пер б = ЦЗОП("Высота?")
печать(площадь(а, б))

функция самое_большое принимает аргументы а, б начало функции
	если а больше б то
		вернуть а
	конец
	вернуть б
конец функции
пер а = ЦЗОП("Первое число")
пер б = ЦЗОП("Второе число")
печать(самое_большое(а, б))

функция надёжный принимает аргументы пароль начало функции
	если пароль длина большеравно 8 то
		вернуть "да"
	конец
	вернуть "нет"
конец функции
пер пароль = ЗОП("Придумайте пароль")
печать(надёжный(пароль))

функция степень принимает аргументы основание, показатель начало функции
	пер результат = 1
	запустить цикл показатель раза то
		результат = результат * основание
	конец
	вернуть результат
конец функции
пер основание = ЦЗОП("Основание?")
пер показатель = ЦЗОП("Показатель?")
печать(степень(основание, показатель))

функция факториал принимает аргументы н начало функции
	если н меньшеравно 1 то
		вернуть 1
	конец
	вернуть н * факториал(н - 1)
конец функции
пер н = ЦЗОП("Введите число")
печать(факториал(н))

пер а = ЦЗОП("Первое число")
пер б = ЦЗОП("Второе число")
пока а не равно б то
	если а больше б то
		а = а - б
	конец
	иначе
		б = б - а
	конец
конец
печать(а)

функция фибоначчи принимает аргументы н начало функции
	если н меньшеравно 2 то
		вернуть 1
	конец
	вернуть фибоначчи(н - 1) + фибоначчи(н - 2)
конец функции
пер н = ЦЗОП("Номер числа Фибоначчи")
печать(фибоначчи(н))

Дальше — Глава 8: ошибки. Учимся читать сообщения переводчика и исправлять типичные промахи новичка.

Глава 8. Ошибки: программа объясняет, что не так

Ошибки — не враги, а подсказки. Даже опытные программисты видят ошибки по десять раз на дню: компьютер просто сообщает, где именно он не понял вашу мысль. Научимся читать его сообщения и ловить ошибку «в руки».

Шаг 1. Сообщение об ошибке

Вот программа с ошибкой — запустите и посмотрите, что напишет компьютер:

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

• несозданная — имя, которое компьютер не смог найти;
• не определена/объявлена — причина: переменную не создавали командой пер;
• около строки 2 вашей программы — где искать.

Часть после ошибки («около строки 2») — самый ценный кусок. Идите на эту строку и смотрите внимательно.

Шаг 2. Словарь частых ошибок

Компьютер пишет по-английски, но переводчик переводит главное:

Вот как выглядит ошибка структуры — не хватает конец:

Компьютер ещё до запуска предупредил о нехватке скобок и указал строку — не поленитесь прочитать предупреждение до сообщения об ошибке.

Шаг 3. Ловим ошибку: попробовать выполнить

Иногда ошибка — это нормальная ситуация: пользователь ввёл чушь, файла нет, ответ пришёл пустой. Для таких случаев есть страховка — попробовать выполнить. Компьютер пытается выполнить код, а если случается ошибка — не падает, а переходит в блок уловить ошибку:

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

Шаг 4. Вне зависимости от ошибок

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

Порядок всегда такой: попробовать выполнить → уловить ошибку → вне зависимости от ошибок. Каждый блок — со своим начало и конец.

Страховка — не способ спрятать ошибку от себя. Поймав ошибку, печатайте её: печать("Проблема: " + ошибка) — иначе вы никогда не узнаете, что сломалось.

Шаг 5. Как искать ошибку самому

Когда сообщение непонятно, работает простой приём:

1. Прочитайте номер строки — идите туда.
2. Проверьте кавычки и скобки на этой строке.
3. Проверьте, что все переменные созданы через пер.
4. Не помогло — напечатайте промежуточные значения: печать("проверка: " + число) перед подозрительной строкой.
5. Всё равно не помогло — закомментируйте половину кода однострочным

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

Задания к главе

Напишите решение в редакторе и нажмите «Проверить». Застряли — откройте подсказку, потом решение.

печать("Старт")
попробовать выполнить начало
	печать(несозданная)
конец
уловить ошибку(ошибка) начало
	печать("Поймали")
конец
печать("Финиш")

пер слово = ЗОП("Что делаем?")
попробовать выполнить начало
	печать("Прыгаем!")
	если слово равно "ломаем" то
		печать(сломанная)
	конец
конец
уловить ошибку(ошибка) начало
	печать("Не упали!")
конец
печать("Приземлились")

пер слово = ЗОП("Введите слово")
попробовать выполнить начало
	если слово равно "ошибка" то
		печать(несозданная)
	конец
конец
уловить ошибку(ошибка) начало
	печать("Починили")
конец
вне зависимости от ошибок начало
	печать("Конец программы")
конец

пер н = ЦЗОП("Введите число")
пока проверка числа(н) не равно правда то
	печать("Это не число!")
	н = ЦЗОП("Попробуйте ещё раз")
конец
печать("Принято: " + н)

Шаг 5. Своя ошибка: бросить ошибку

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

Запустите с числом 999 — сообщение увидит пользователь, и выполнение прекратится. Свои ошибки лучше «Unable to read property»: они говорят человеческим языком, что именно не так.

Дальше — Глава 9: строки. Слово можно измерить, перекрасить, разрезать и склеить.

Глава 9. Строки: измеряем, перекрашиваем, режем

Строка — это не просто «текст для печати». Это значение, с которым можно работать: измерить, поменять регистр, повторить, разрезать на кусочки и склеить обратно. Всё это нужно для игр с текстом, чатов и паролей.

Шаг 1. Длина и регистр

Команда длина считает символы (мы уже проверяли ею пустой ответ). Команды в верхний регистр и в нижний регистр перекрашивают буквы:

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

Шаг 2. Повтор строки

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

Это идеальный способ рисовать разделители в консольных программах:

Шаг 3. Разрезаем строку: разбить строку

Команда разбить строку режет строку на список кусочков. В скобках — разделитель: что считать «ножом»:

Если разрезать пустым разделителем (""), строка развалится на отдельные буквы — получится список символов:

Кусочки после разреза — это список. Со списками мы подробно познакомимся в Главе 10.

Шаг 4. Замена и склейка обратно

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

Сама строка не меняется — команда возвращает новую строку. И по умолчанию заменяется только первое совпадение.

Обратная операция — склеить список кусочков в строку — называется объединить массив; в скобках пишут, чем соединять кусочки:

Шаг 5. Символ по номеру

У каждого символа в строке есть номер — и он начинается с нуля! Первый символ — номер 0, второй — 1 и так далее. Символ берут квадратными скобками:

Последний символ — номер «длина минус один», потому что нумерация с нуля:

Шаг 8. Инструменты строк: срез, проверка концов, дополнение

У строк много готовых инструментов. Самый нужный — срез: вырезать часть строки по номерам символов (первый — 0):

Про проверку концов: начинается с и кончается на отвечают правдой/ложью — удобно для файлов и команд:

А заполнить слева дописывает символы до нужной длины — так делают часы «09:05» вместо «9:5»:

Ещё есть переписать целиком("а", "б") — заменить ВСЕ вхождения (обычный заменить меняет только первое), и включает("…") — проверить, входит ли кусок в строку.

Задания к главе

Напишите решение в редакторе и нажмите «Проверить». Застряли — откройте подсказку, потом решение.

пер слово = ЗОП("Введите слово")
печать(слово в верхний регистр)
печать(слово длина)

пер заголовок = ЗОП("Введите заголовок")
печать(заголовок + " " + "-" повторить строку(10))

пер слово = ЗОП("Введите слово")
печать(слово[0])
печать(слово[слово длина - 1])

пер фраза = ЗОП("Введите фразу")
пер слова = фраза разбить строку(" ")
печать(слова количество элементов в массиве)
запустить цикл слово в массиве слова то
	печать(слово)
конец

пер слово = ЗОП("Введите слово")
пер буквы = слово в нижний регистр разбить строку("")
печать(буквы объединить массив("-"))

пер фраза = ЗОП("Введите фразу")
печать(фраза заменить(" ", "_"))

пер фраза = ЗОП("Введите фразу")
пер слова = фраза разбить строку(" ")
пер сплошь = слова объединить массив("")
пер малый = сплошь в нижний регистр
пер буквы = малый разбить строку("")
буквы перевернуть массив
пер задом = буквы объединить массив("")
если задом равно малый то
	печать("да")
конец
иначе
	печать("нет")
конец

пер ч = ЦЗОП("Сколько часов?")
пер м = ЦЗОП("Сколько минут?")
печать(ч заполнить слева(2, "0") + ":" + м заполнить слева(2, "0"))

пер имя = ЗОП("Имя файла?")
если имя начинается с("рис") и имя кончается на(".ряп") то
	печать("подходит")
конец
иначе
	печать("не подходит")
конец

Дальше — Глава 10: списки. Одна переменная, в которой живёт целая коллекция значений.

Глава 10. Списки: много значений в одной переменной

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

Шаг 1. Создаём список

Список пишется в квадратных скобках, значения через запятую:

Команда количество элементов в массиве отвечает на вопрос «сколько тут лежит?». Обратиться к одному значению можно по номеру — как со строками, нумерация с нуля:

Шаг 2. Кладём и вынимаем

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

Так делают любые «накопители»: очередь в игре, история ходов, дневник измерений. Классика — накопление в цикле:

Шаг 3. Перебираем список

Цикл умеет перебирать список сам: запустить цикл <имя> в массиве <список> то — на каждом витке <имя> получает очередное значение:

Перебор + условие = поиск нужного элемента:

Шаг 4. Ищем в списке

Две команды поиска. есть ли элемент в массиве отвечает да/нет (правда или ложь), поиск в массиве говорит номер элемента — или минус один, если элемента нет:

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

Шаг 5. Наводим порядок: сортировка и переворот

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

Из «по возрастанию» получаем «по убыванию»: сортируем и переворачиваем:

Внимание: сортировка сравнивает значения «как в словаре», то есть как текст. Для однозначных чисел (1–9) это совпадает с обычным порядком, а вот 90 окажется «больше» 500 — потому что «9» по словарю позже «5». Сортировку чисел «по-настоящему» делают своей функцией — этому учат курсы посложнее.

Шаг 6. Для любопытных: фильтр

Список можно «просеять» одной командой — отфильтровать массив. Внутри пишут правило, и остаются только значения, для которых оно верно:

Здесь внутри скобок спрятана крошечная функция-проверка (о функциях — Глава 7). Пока можете просто запомнить шаблон: список отфильтровать массив(безимянная функция(х) начало вернуть <условие> конец).

Шаг 6. Потрогайте список руками

Каждая кнопка — настоящая команда из главы. Нажимайте и смотрите, что происходит со списком и с какими номерами:

Номера в квадратных скобках — индексы. Первый элемент всегда [0] — это не ошибка, а договорённость всего программирования.

Задания к главе

Напишите решение в редакторе и нажмите «Проверить». Застряли — откройте подсказку, потом решение. Числа приходят строками: для арифметики превращайте их командой преобразовать строку в число.

пер текст = ЗОП("Введите числа через пробел")
пер числа = текст разбить строку(" ")
пер сумма = 0
запустить цикл х в массиве числа то
	сумма = сумма + преобразовать строку в число(х)
конец
печать(сумма)

пер текст = ЗОП("Введите числа через пробел")
пер числа = текст разбить строку(" ")
пер самое = преобразовать строку в число(числа[0])
запустить цикл х в массиве числа то
	если преобразовать строку в число(х) больше самое то
		самое = преобразовать строку в число(х)
	конец
конец
печать(самое)

пер текст = ЗОП("Введите числа через пробел")
пер числа = текст разбить строку(" ")
запустить цикл х в массиве числа то
	если преобразовать строку в число(х) остаток от деления на 2 равно 0 то
		печать(х)
	конец
конец

пер слово = ЗОП("Введите слово")
пер буквы = слово разбить строку("")
буквы перевернуть массив
печать(буквы объединить массив(""))

пер фрукты = ["яблоко", "груша", "слива", "ананас"]
пер слово = ЗОП("Какой фрукт?")
пер номер = фрукты поиск в массиве(слово)
если номер равно -1 то
	печать("Нет такого")
конец
иначе
	печать("Есть! Номер: " + номер)
конец

пер текст = ЗОП("Введите числа через пробел")
пер числа = текст разбить строку(" ")
числа перевернуть массив
печать(числа объединить массив(" "))

пер н = ЦЗОП("Длина острова")
пер текст = ЗОП("Высоты через пробел")
пер высоты = текст разбить строку(" ")
пер слева = []
пер справа = []
запустить цикл н раза то
	слева добавить элемент в массив(0)
	справа добавить элемент в массив(0)
конец
пер текущий = 0
пер столб = 0
пока столб меньше н то
	если преобразовать строку в число(высоты[столб]) больше текущий то
		текущий = преобразовать строку в число(высоты[столб])
	конец
	слева[столб] = текущий
	столб = столб + 1
конец
текущий = 0
столб = н - 1
пока столб большеравно 0 то
	если преобразовать строку в число(высоты[столб]) больше текущий то
		текущий = преобразовать строку в число(высоты[столб])
	конец
	справа[столб] = текущий
	столб = столб - 1
конец
пер верх = слева[н - 1]
пер уровень = верх
пока уровень большеравно 1 то
	пер полоса = ""
	пер край = 0
	столб = 0
	пока столб меньше н то
		если преобразовать строку в число(высоты[столб]) большеравно уровень то
			полоса = полоса + "#"
			край = столб
		конец
		иначе
			если справа[столб] большеравно уровень то
				если слева[столб] большеравно уровень то
					полоса = полоса + "~"
					край = столб
				конец
				иначе
					полоса = полоса + " "
				конец
			конец
			иначе
				полоса = полоса + " "
			конец
		конец
		столб = столб + 1
	конец
	печать((полоса.slice(0, край + 1)) удалить пробелы)
	уровень = уровень - 1
конец

пер текст = ЗОП("Введите числа через пробел")
пер числа = текст разбить строку(" ")
пер н = числа количество элементов в массиве
пер м = 0
пока м меньше н то
	пер мин_место = м
	пер мин_значение = преобразовать строку в число(числа[м])
	пер к = м + 1
	пока к меньше н то
		если преобразовать строку в число(числа[к]) меньше мин_значение то
			мин_значение = преобразовать строку в число(числа[к])
			мин_место = к
		конец
		к = к + 1
	конец
	пер запас = числа[м]
	числа[м] = числа[мин_место]
	числа[мин_место] = запас
	м = м + 1
конец
печать(числа объединить массив(" "))

пер текст = ЗОП("Введите числа через пробел")
пер числа = текст разбить строку(" ")
пер самый = -1000000000
пер второй = -1000000000
запустить цикл х в массиве числа то
	если преобразовать строку в число(х) больше самый то
		второй = самый
		самый = преобразовать строку в число(х)
	конец
	иначе если преобразовать строку в число(х) больше второй то
		второй = преобразовать строку в число(х)
	конец
конец
печать(второй)

Дальше — Глава 11: случайность. Компьютер научится бросать кубик за вас.

Глава 11. Случайность: компьютер бросает кубик

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

Шаг 1. Случайное число

математика-случайное число даёт дробь от 0 до 1, а округлить — округляет до целого. Вместе они умеют бросать кубик любого размера:

Каждая строка получает своё случайное число от 0 до 6 — запустите демо несколько раз. А чтобы получить кубик со значениями от 1 до 6, добавляем единицу:

Запомните пару: «случайное число * 5) + 1» — это кубик 1–6. Умножение на 5 даёт 0–5, прибавка единицы сдвигает на 1–6.

Шаг 2. Дробное случайное число

Для тонкой настройки берут дробное значение без округления — например, чтобы «с вероятностью 30%» произошло событие (дробь меньше 0.3 — примерно треть всех случаев):

Шаг 3. Случайный выбор из списка

Случайное число + список = случайный выбор. Номер элемента берём случайный — от 0 до «количество минус один»:

Так делаются предсказания, случайные реплики соперника в играх и генераторы имён:

Шаг 4. Угадайка

Соберём всё вместе: случайный секрет, цикл-попытки, подсказки «больше — меньше». Команда выход из цикла завершает цикл досрочно, как только вы угадали:

Обратите внимание: секрет задаётся один раз до цикла, а внутри цикла каждый раз задаётся новый вопрос. Если убрать строку попытка = попытка + 1, цикл станет вечным — но защита от вечных циклов остановит его и подскажет, где ошибка.

Шаг 5. Мастер случайности: подбрасываем монетку

Классика задач со случайностью — половина диапазона: 0 — «орёл», 1 — «решка»:

Запустите второй пример несколько раз: около 500, но никогда не точно — в этом и есть случайность.

Задания к главе

пер загаданное = ЦЗОП("Загадайте число")
пер попытка = ЦЗОП("Ваша догадка")
пока попытка не равно загаданное то
	если попытка меньше загаданное то
		печать("больше")
	конец
	иначе
		печать("меньше")
	конец
	попытка = ЦЗОП("Ваша догадка")
конец
печать("Угадал!")

пер н = ЦЗОП("Сколько бросков?")
пер орлов = 0
пер решек = 0
запустить цикл н раза то
	пер ответ = ЗОП("о или р?")
	если ответ равно "о" то
		орлов = орлов + 1
	конец
	иначе
		решек = решек + 1
	конец
конец
печать("Орлов: " + орлов)
печать("Решек: " + решек)

пер бросков = 1
пер кость = округлить(математика-случайное число * 5) + 1
пока кость не равно 6 то
	печать("Выпало: " + кость)
	бросков = бросков + 1
	кость = округлить(математика-случайное число * 5) + 1
конец
печать("Выпало: " + кость)
печать("Понадобилось " + бросков + " бросков")

Дальше — Глава 12: сортировки. Компьютер раскладывает всё по порядку — и мы узнаем, сколько это стоит.

Глава 12. Сортировки: порядок из хаоса

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

Шаг 1. Готовая сортировка и её ловушка

В языке уже есть команда отсортировать элементы в массиве:

Со словами всё отлично. А теперь секрет:

1, 10, 100, 9 — потому что по умолчанию массив сортируется как строки: «100» начинается с «1», а «9» — позже. Для чисел есть специальная команда отсортировать числа — она сравнивает числа как числа:

с отсортировать числа меняет сам список. Если оригинал нужен нетронутым — с отсортировать копию чисел вернёт новый отсортированный список.

Шаг 2. Пузырёк: сортировка своими руками

Как бы вы отсортировали карты в руке? Пузырёк делает так: пробегает по списку, сравнивает соседей и меняет их местами, если они не по порядку. Самое большое число «всплывает» в конец за один проход:

Обмен двух ячеек — через третью переменную (запаска): просто «с[а] = с[б] и с[б] = с[а]» нельзя — второе присваивание затрёт первое значение. Это приём, который нужен везде.

Шаг 3. Посмотрите на пузырёк вживую

Нажимайте «Шаг» и следите за подсвеченной парой: сколько проходов нужно, чтобы массив почти отсортировался? А если массив уже отсортирован — сколько проходов тратится зря?

Шаг 4. Сколько это стоит?

В списке из n элементов пузырёк делает примерно n × n сравнений — n на каждой из n дорожек. Рост взрывной:

Удвоили список — работа выросла в четыре раза. Программисты говорят «сложность n квадрат» и записывают O(n²). Встроенная сортировка умнее (около n × log n) — на 10 000 элементах это примерно 130 000 операций вместо 100 000 000. Разница — в сотни раз, и сейчас вы её померяете сами.

Выберите размер списка и нажмите «Измерить»: интерактив реально запускает три сортировки на случайных данных и рисует время работы. Попробуйте 100, потом 500, потом 2000 — как растут столбики?

Шаг 5. Поиск: линейный и пополам

А как быстро найти число в отсортированном списке? Линейно — перебрать все. Но есть трюк умнее — половинное деление: смотрим в середину и сразу выкидываем половину списка. Знакомо? Это «Угадайка» из Главы 11!

Загадайте число от 1 до 100 и нажмите «Машина угадывает»: машина задаст не больше 7 вопросов, потому что 100 ÷ 2 семь раз меньше единицы. Для миллиона чисел хватает 20 вопросов. Это и есть сила порядка: O(log n).

Пополам ищут только в ОТСОРТИРОВАННОМ списке. Сортировка стоит времени один раз — зато каждый поиск потом почти мгновенный. Так думает словарь в вашей голове.

Шаг 6. Операции со списком вживую

Команды из Главы 11 (вставить в начало, вырезать из массива…) — потрогайте каждую и посмотрите на код, который за ней стоит:

Задания к главе

пер текст = ЗОП("Введите числа через пробел")
пер с = текст разбить строку(" ")
запустить цикл (с длина) раза то
	с[счетчик] = преобразовать строку в число(с[счетчик])
конец
запустить цикл (с длина - 1) раза то
	запустить цикл (с длина - 1 - счетчик) раза то
		если с[счетчик] больше с[счетчик + 1] то
			пер запаска = с[счетчик]
			с[счетчик] = с[счетчик + 1]
			с[счетчик + 1] = запаска
		конец
	конец
	печать(с объединить массив(" "))
конец

пер н = ЦЗОП("Размер списка")
печать(целое снизу(н * (н - 1) / 2))

пер загаданное = ЦЗОП("Загадайте число")
пер низ = 1
пер верх = 100
пер середина = целое снизу((низ + верх) / 2)
печать(середина)
пока середина не равно загаданное то
	пер ответ = ЗОП("больше или меньше?")
	если ответ равно "больше" то
		низ = середина + 1
	конец
	иначе
		верх = середина - 1
	конец
	середина = целое снизу((низ + верх) / 2)
	печать(середина)
конец
печать("Угадал!")

пер текст = ЗОП("Введите числа через пробел")
пер с = текст разбить строку(" ")
запустить цикл (с длина) раза то
	с[счетчик] = преобразовать строку в число(с[счетчик])
конец
запустить цикл (с длина) раза то
	пер наименьший = счетчик
	пер ж = счетчик + 1
	пока ж меньше с длина то
		если с[ж] меньше с[наименьший] то
			наименьший = ж
		конец
		ж = ж + 1
	конец
	если наименьший не равно счетчик то
		пер запаска = с[счетчик]
		с[счетчик] = с[наименьший]
		с[наименьший] = запаска
	конец
	печать(с объединить массив(" "))
конец

пер текст = ЗОП("Введите числа через пробел")
пер с = текст разбить строку(" ")
запустить цикл (с длина) раза то
	с[счетчик] = преобразовать строку в число(с[счетчик])
конец
пер обменов = 0
запустить цикл (с длина - 1) раза то
	запустить цикл (с длина - 1 - счетчик) раза то
		если с[счетчик] меньше с[счетчик + 1] то
			пер запаска = с[счетчик]
			с[счетчик] = с[счетчик + 1]
			с[счетчик + 1] = запаска
			обменов = обменов + 1
		конец
	конец
конец
печать(обменов)
печать(с объединить массив(" "))

Дальше — Глава 13: словари. Одна переменная, в которой у каждого значения есть своё имя.

Глава 13. Словари: значения с именами

Список — коробка с номерами: значение №0, №1, №2. Но часто удобнее обращаться к значениям по имени: у игрока есть «очки», «уровень», «имя». Для этого есть словарь — коллекция пар «ключ: значение».

Шаг 1. Создаём словарь и читаем его

Словарь пишется в фигурных скобках: ключ, двоеточие, значение. Доступ — через точку:

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

Ключи могут быть и списками — так строят «карточки персонажей»:

Шаг 2. Ключи и значения как списки

Иногда нужно перебрать всё содержимое словаря. Три команды превращают словарь в список:

У команд есть короткие имена: ККОМ (ключи), КЗОМ (значения), КОМ (и то и другое). Перебираем словарь целиком:

Обратите внимание: когда ключ «в переменной», к нему обращаются квадратными скобками — игрок[ключ], а не точкой.

Шаг 3. JSON: словарь как текст

Для сохранения и пересылки словарь превращают в текст командой конвертация в JASON, а обратно — конвертация из JASON. Такой формат называется JSON, и он одинаковый на всех языках программирования мира:

Это и есть способ сохранять прогресс: превратили словарь в текст, сохранили (об этом — Глава 19), потом собрали обратно.

Шаг 4. Копия словаря

Простое присваивание не копирует словарь, а даёт ему второе имя — изменения видны через оба:

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

Шаг 5. Удаляем ключ

удалить элемент вычёркивает ключ из словаря навсегда:

Задания к главе

Напишите решение в редакторе и нажмите «Проверить». Застряли — откройте подсказку, потом решение.

пер имя = ЗОП("Имя игрока")
пер очки = ЦЗОП("Сколько очков?")
пер игрок = { имя: имя, очки: очки }
печать(игрок.имя + " — " + игрок.очки + " очков")

пер старт = ЦЗОП("Начальные очки")
пер добавка = ЦЗОП("Сколько добавить?")
пер банк = { очки: старт }
банк.очки = банк.очки + добавка
печать(банк.очки)

пер столицы = { Россия: "Москва", Франция: "Париж", Италия: "Рим", Япония: "Токио" }
пер страна = ЗОП("Какая страна?")
если столицы[страна] равно нет значения то
	печать("Не знаю")
конец
иначе
	печать(столицы[страна])
конец

пер имя = ЗОП("Как тебя зовут?")
пер число = ЦЗОП("Любимое число")
пер анкета = { имя: имя, число: число }
печать(конвертация в JASON(анкета))

пер очки = ЦЗОП("Сколько очков?")
пер игрок = { очки: очки }
пер двойник = игрок
двойник.очки = 999
печать(игрок.очки)

пер имя = ЗОП("Имя героя")
пер уровень = ЦЗОП("Уровень")
пер герой = { имя: имя, уровень: уровень }
печать(конвертировать ключи обьекта в массив(герой) объединить массив(", "))

пер слово = ЗОП("Введите слово")
пер буквы = слово разбить строку("")
пер счёт = {}
запустить цикл б в массиве буквы то
	если счёт[б] равно нет значения то
		счёт[б] = 1
	конец
	иначе
		счёт[б] = счёт[б] + 1
	конец
конец
печать(конвертация в JASON(счёт))

Дальше — Глава 14: классы. Свои типы значений с собственными командами.

Глава 14. Классы: свои типы значений

Словарь собрал свойства в одну карточку. Но герою нужно не только хранить очки — он должен уметь действовать. Класс — это чертёж: описываем один раз, а потом создаём сколько угодно «экземпляров», каждый со своими данными и своими командами.

Шаг 1. Первый класс

Класс описывается командой класс, внутри — конструктор (что делать при создании) и методы (обычные команды-функции, принадлежащие классу). Создаётся экземпляр командой новый:

Разбор по строкам:

• класс Кот начало — объявляем чертёж с именем Кот;
• конструктор(имя) — выполняется при каждом новый Кот(...);
• этот элемент имя = имя — «моё имя = то, что передали». Слова

этот элемент означают «именно этого кота, не любого другого»;

• мяу() начало … конец — команда, которую умеет каждый кот;
• барсик.мяу() — просим конкретного кота мяукнуть.

Шаг 2. Сколько угодно экземпляров

Один чертёж — много котов, и у каждого своё имя и свои свойства:

У Барсика и Мурки отдельные сытости: каждый экземпляр хранит свои значения, но команды у них общие — описаны один раз в классе.

Шаг 3. Команды с параметрами

Методы принимают значения так же, как функции из Главы 7:

Так устроены игровые объекты: герой.урон(10), счёт.добавить(1), магазин.продать("хлеб").

Шаг 4. Наследование: расширить класс

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

Кот и Собака оба умеют познакомься — эта команда описана один раз в Животном. Общее — в родителя, особенное — в наследнике:

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

Задания к главе

Напишите решение в редакторе и нажмите «Проверить». Застряли — откройте подсказку, потом решение.

класс Кот начало
	конструктор(имя) начало
		этот элемент имя = имя
	конец
	поздороваться() начало
		печать("Мяу, я " + этот элемент имя + "!")
	конец
конец
пер имя = ЗОП("Как зовут кота?")
пер барсик = новый Кот(имя)
барсик.поздороваться()

класс Счётчик начало
	конструктор(старт) начало
		этот элемент число = старт
	конец
	добавить(n) начало
		этот элемент число = этот элемент число + n
	конец
	показать() начало
		печать("Счётчик: " + этот элемент число)
	конец
конец
пер старт = ЦЗОП("С какого числа начинаем?")
пер счёт = новый Счётчик(старт)
счёт.добавить(ЦЗОП("Первая прибавка"))
счёт.добавить(ЦЗОП("Вторая прибавка"))
счёт.показать()

класс Кот начало
	конструктор(имя) начало
		этот элемент имя = имя
	конец
	поздороваться() начало
		печать("Мяу, я " + этот элемент имя + "!")
	конец
конец
пер первый = ЗОП("Имя первого кота")
пер второй = ЗОП("Имя второго кота")
пер кот1 = новый Кот(первый)
пер кот2 = новый Кот(второй)
кот1.поздороваться()
кот2.поздороваться()

класс Животное начало
	конструктор(имя) начало
		этот элемент имя = имя
	конец
	познакомься() начало
		печать("Я — " + этот элемент имя + "!")
	конец
конец
класс Кот расширить класс Животное начало
	мяу() начало
		печать("Мяу, я " + этот элемент имя + "!")
	конец
конец
пер имя = ЗОП("Как зовут кота?")
пер барсик = новый Кот(имя)
барсик.познакомься()
барсик.мяу()

класс Банк начало
	конструктор(старт) начало
		этот элемент деньги = старт
	конец
	положить(n) начало
		этот элемент деньги = этот элемент деньги + n
	конец
	снять(n) начало
		если n меньшеравно этот элемент деньги то
			этот элемент деньги = этот элемент деньги - n
		конец
	конец
конец
пер старт = ЦЗОП("Стартовый баланс")
пер счёт = новый Банк(старт)
счёт.снять(ЦЗОП("Сколько снять?"))
счёт.положить(ЦЗОП("Сколько положить?"))
счёт.снять(ЦЗОП("Сколько снять ещё?"))
печать(счёт.деньги)

Дальше — Глава 15: холст. Рисуем настоящую графику — для этого шага понадобится компилятор ryap.exe из Главы 0.

Глава 15. Холст: рисуем графику

До сих пор программы отвечали текстом. Теперь — графика! Холст — это белый лист прямо в редакторе: запустите пример — и под кодом появится рисунок. Те же программы работают и в компиляторе ryap.exe.

Холст в учебнике — 400 на 320 пикселей. Точка (0, 0) — левый верхний угол: вправо растёт первая координата, вниз — вторая.

Шаг 1. Первый прямоугольник

Команда содержание холста достаёт кисть (записывает её в переменную холст). Команда нарисовать прямоугольник рисует прямоугольник: слева, сверху, ширина, высота:

Шаг 2. Цвета

цвет заливки задаёт цвет для всех следующих фигур. Есть готовые названия цветов:

А так рисуется круг — нарисовать круг(х, у, радиус): х и у — центр, радиус — расстояние от центра до края. Заливается текущим цветом:

Кисть запоминает цвет до следующего изменения: «цвет заливки — потом сколько угодно фигур этим цветом».

Шаг 3. Настраивающие и рисующие команды

Команды холста бывают двух видов. Настраивающие меняют кисть и аргументов не имеют: цвет заливки красный, ширина линии 3. Рисующие рисуют — у них в скобках аргументы через запятую, как у обычных команд: нарисовать прямоугольник(10, 10, 60, 60).

Шаг 4. Очистка холста

Рисунки накапливаются: каждая фигура ложится поверх предыдущих. очистить холст стирает всё до белого листа:

После очистки останется только второй прямоугольник. Очистка — главный инструмент анимации (об этом в следующей главе).

Шаг 5. Линии

Рисование линии — это маршрут: «поднять ручку» (рисовка линий), поставить точку (провести линию из точки), вести линию (провести линию в точку), «отрисовать» (завершить рисовку линий):

Из точки в точку можно вести сколько угодно линий — получится ломаная. Команда заполнить фигуры заливает замкнутый контур текущим цветом заливки. Команда провести линию из первой точки в последнюю замыкает контур — соединяет последнюю точку с первой.

Шаг 6. Текст на холсте

Текст тоже рисуется как фигура — командой нарисовать текст. Размер шрифта задаёт размер шрифта текста:

Шаг 7. Короткие имена

У четырёх главных команд холста есть сокращения для быстрого письма:

Шаг 8. Кисть: помни состояние

У кисти есть «память» — её можно сохранять и восстанавливать. Зачем? Чтобы повернуть или сдвинуть кисть, нарисовать, а потом вернуть всё как было — и не портить следующие фигуры:

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

Правило хорошего тона: делаете сдвиг/поворот/прозрачность — оберните в сохранить кисть … восстановить кисть. Кисть-память — стек: можно сохранять несколько раз и восстанавливать в обратном порядке.

Шаг 9. Дом: собираем всё вместе

Домик из прямоугольника и крыши — теперь прямо здесь, жмите «Запустить»:

Проверить себя просто: пиксель (160, 150) должен быть жёлтым — это стена дома. Автопроверка в заданиях этой главы устроена так же: она «смотрит» в указанные точки холста.

Задания к главе

содержание холста
цвет заливки красный
нарисовать прямоугольник(20, 100, 60, 60)
цвет заливки желтый
нарисовать прямоугольник(100, 100, 60, 60)
цвет заливки зеленый
нарисовать прямоугольник(180, 100, 60, 60)

содержание холста
цвет заливки серый
нарисовать прямоугольник(20, 240, 60, 40)
нарисовать прямоугольник(100, 180, 60, 40)
нарисовать прямоугольник(180, 120, 60, 40)

содержание холста
цвет заливки серый
нарисовать прямоугольник(180, 100, 40, 120)
цвет линии красный
ширина линии 3
рисовка линий
провести линию из точки(180, 100)
провести линию в точку(200, 60)
провести линию в точку(220, 100)
завершить рисовку линий
заполнить фигуры
цвет заливки оранжевый
нарисовать прямоугольник(190, 220, 20, 40)
цвет заливки белый
нарисовать прямоугольник(190, 130, 20, 20)
цвет заливки черный
размер шрифта текста "20px Arial"
нарисовать текст("Поехали!", 130, 290)

содержание холста
функция дом принимает аргументы х, у, цвет начало функции
	цвет заливки цвет
	нарисовать прямоугольник(х, у, 60, 40)
	цвет линии красный
	ширина линии 3
	рисовка линий
	провести линию из точки(х - 10, у)
	провести линию в точку(х + 30, у - 30)
	провести линию в точку(х + 70, у)
	завершить рисовку линий
	заполнить фигуры
	цвет заливки белый
	нарисовать прямоугольник(х + 24, у + 14, 12, 12)
конец функции
дом(30, 180, "золотой")
дом(150, 160, "розовый")
дом(280, 190, "лаймовый")
цвет заливки серый
нарисовать прямоугольник(0, 290, 400, 30)

содержание холста
цвет заливки синий
нарисовать круг(80, 200, 30)
цвет заливки водный
нарисовать круг(200, 200, 30)
цвет заливки фиолетовый
нарисовать круг(320, 200, 30)

Дальше — Глава 16: движение. Заставим фигуры летать: интервал, задержка и покадровая анимация.

Глава 16. Холст: движение и анимация

Мультик — это много картинок, сменяющихся быстро: каждый «кадр» картинка немного сдвигается, и глаз видит движение. Компьютер умеет повторять код по расписанию — этим и делают анимацию. Демо этой главы живут прямо в учебнике: жмите «Запустить» и смотрите.

Шаг 1. Повтор по расписанию: интервал

Команда интервал повторяет блок кода каждые N миллисекунд (1000 миллисекунд = секунда):

Читается так: «интервал ( безымянная функция ) начало … конец, повторять каждые 1000 мс». Каждый «Тик!» — новый кадр по будильнику. Будильник тикает, пока открыта страница, поэтому при перезапуске демо старый интервал сначала гасится.

Шаг 2. Кадры: очистить — сдвинуть — нарисовать

Анимация — это три шага в каждом кадре: стереть, изменить, нарисовать. Двигаем квадрат вправо:

Каждые 30 миллисекунд холст очищается, х растёт на 2 — и квадрат рисуется на новом месте. Квадрат уедет за край холста и исчезнет — границ он пока не знает.

Шаг 3. Отскок от стены

Меняя х, проверяем границы: долетел до правого края — двигайся назад. Для этого направление тоже храним в переменной и меняем его знак:

Квадрик летает туда-сюда. -скорость — «минус скорость»: когда скорость была 2, станет −2, и движение пойдёт в обратную сторону.

Шаг 4. Двумерное движение: мяч

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

Шаг 5. Разовое отложенное действие: задержка

интервал повторяет бесконечно. А задержка выполняет блок один раз, через указанное время — например, через полторы секунды после запуска:

Читается: «задержка ( функция ) … конец, через 1500 мс». Так делают отсчёт «3, 2, 1, старт!» и переходы между экранами игры.

Шаг 6. Один кадр: анимировать холст

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

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

Шаг 7. Поворот фигуры

Фигуры можно вращать. повернуть фигуру поворачивает кисть на угол в радианах (полный оборот ≈ 6.28) — все следующие фигуры лягут под углом. Оборот стрелки удобно делать через время:

Команда время из Главы 19 даёт миллисекунды — деля на 1000, получаем постоянно растущее число секунд, из которого получается плавный поворот.

Шаг 8. Правила хорошего мультика

• Сначала очистить холст, потом рисовать — иначе кадры намажутся друг

на друга;

• все изменяемые величины (х, у, скорость) — в переменных до цикла;
• скорость меняйте внутри кадра, а не создавайте заново;
• интервал 30 мс даёт плавное движение без перегрузки компьютера.

Задания к главе

содержание холста
пер х = 40
пер у = 40
пер сх = 4
пер су = 3
интервал(безимянная функция() начало
	очистить холст
	х = х + сх
	у = у + су
	если х больше 380 или х меньше 0 то
		сх = -сх
	конец
	если у больше 300 или у меньше 0 то
		су = -су
	конец
	цвет заливки красный
	нарисовать прямоугольник(х, у, 20, 20)
конец, 30)

содержание холста
функция светофор принимает аргументы цвет, верх начало функции
	очистить холст
	цвет заливки "DarkSlateGray"
	нарисовать прямоугольник(40, 40, 60, 180)
	цвет заливки "DarkRed"
	нарисовать прямоугольник(50, 50, 40, 40)
	цвет заливки "DarkKhaki"
	нарисовать прямоугольник(50, 110, 40, 40)
	цвет заливки "DarkGreen"
	нарисовать прямоугольник(50, 170, 40, 40)
	цвет заливки цвет
	нарисовать прямоугольник(50, верх, 40, 40)
конец функции
светофор("red", 50)
задержка(безимянная функция() начало
	светофор("yellow", 110)
конец, 1000)
задержка(безимянная функция() начало
	светофор("lime", 170)
конец, 2000)

содержание холста
пер голова = 10
интервал(безимянная функция() начало
	очистить холст
	голова = голова + 2
	запустить цикл 5 раза то
		если счетчик остаток от деления на 2 равно 0 то
			цвет заливки зеленый
		конец
		иначе
			цвет заливки темно-зеленый
		конец
		нарисовать прямоугольник(голова - счетчик * 22, 100, 20, 20)
	конец
конец, 30)

содержание холста
пер х = 60
пер у = 60
пер сх = 4
пер су = 3
интервал(безимянная функция() начало
	очистить холст
	х = х + сх
	у = у + су
	если х больше 385 или х меньше 15 то
		сх = -сх
	конец
	если у больше 305 или у меньше 15 то
		су = -су
	конец
	цвет заливки красный
	нарисовать круг(х, у, 15)
конец, 30)

Дальше — Глава 17: события. Программа будет реагировать на мышь и клавиатуру.

Глава 17. События: мышь и клавиатура

До сих пор программа жила своей жизнью: запустилась и работала по сценарию. Событие — это сигнал «снаружи»: пользователь щёлкнул мышью, нажал клавишу. Программа слушает события и реагирует на них — так работают все интерактивные приложения и игры. Демо этой главы живые: запустите, затем щёлкайте по холсту (он поймает фокус) или жмите клавиши — слушатель отзовётся.

Шаг 1. Клик мышью

при нажатии мышкой вешает «слушателя» на всю страницу. Каждый клик — выполняется блок:

позиция клика по x и позиция клика по y говорят, где именно щёлкнули. Нарисуем «трассу» за курсором на холсте:

Шаг 2. Рисуем по клику

Классика «там, где кликнул — там и точка»:

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

Шаг 3. Клавиатура

при нажатии на кнопку слушает клавиатуру. название кнопки — символ или имя клавиши ("a", "5", "Enter", "ArrowLeft"), код кнопки — её числовой код:

Запустите и нажмите разные клавиши: буквы, цифры, стрелки, пробел, Enter. Стрелки называются "ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown".

Шаг 4. Меняем фон страницы клавишей

Событие + свойство страницы — и клавиша перекрашивает весь фон. Этим демо работает только под компилятором ryap.exe — в учебнике фон страницы не менять (остальные демо главы — живые):

при нажатии на кнопку начало
	если название кнопки равно "r" то
		фон страницы красный
	конец
	если название кнопки равно "g" то
		фон страницы зеленый
	конец
	если название кнопки равно "b" то
		фон страницы синий
	конец
конец)

Шаг 5. Управляем фигурой стрелками

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

Нажмите любую стрелку — квадрат шагнёт в её сторону. Это уже почти управление персонажем игры!

Шаг 6. Счётчик кликов

События отлично дружат с переменными-счётчиками — основой любой «статистики» в играх:

Шаг 7. Кнопки и элементы страницы

События бывают и на конкретных элементах. Элемент можно создать прямо в программе — создать html элемент("button"), задать ему текст и повесить своё событие: при нажатии на элемент + команда и конец:

html элемент с айди("...") находит элемент по имени, его html содержание меняет текст внутри него, а ДОКУМЕНТ-body.appendChild добавляет кнопку на страницу. Так делаются интерфейсы: элемент — деталь, событие — реакция на неё.

содержание холста
при нажатии мышкой начало
	цвет заливки красный
	нарисовать круг(позиция клика по x, позиция клика по y, 8)
конец)

при нажатии клавиши начало
	печать("Нажали: " + название клавиши)
конец)

содержание холста
цвет заливки синий
нарисовать круг(200, 150, 50)
при нажатии мышкой начало
	пер dx = позиция клика по x - 200
	пер dy = позиция клика по y - 150
	если (dx * dx + dy * dy) в степени 0.5 меньшеравно 50 то
		печать("Попал!")
	конец
	иначе
		печать("Мимо")
	конец
конец)

Дальше — Глава 18: игры. Собираем всё изученное в одну настоящую игру.

Глава 18. Игры: собираем всё вместе

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

Шаг 1. Схема любой игры

Каждая игра держит в переменных текущее состояние и на каждом кадре пересчитывает его:

Шаг 2. Ловим квадрат: полная игра

Цель — успеть щёлкнуть по убегающему квадрату. Квадрат прыгает каждые полсекунды, игрок кликает; счёт растёт с каждой поимкой:

Разбор по деталям:

• состояние: х, у — где квадрат, очки — счёт;
• прыжки: первый интервал раз в 500 мс ставит квадрат в случайное

место (округлить(математика-случайное число * 300) — по ширине холста);

• ввод: слушатель клика проверяет условие «курсор внутри квадрата»

— четыре сравнения через и;

• кадры: второй интервал рисует сцену: квадрат и надпись с очками.

Два независимых интервала — обычное дело: один меняет мир, другой его рисует.

Шаг 3. Таймер на игру

Добавим обратный отсчёт: игра идёт 15 секунд, потом итог. Время хранится в переменной и уменьшается в кадре:

Один раз в секунду таймер тикает; когда дошёл до нуля — объявляем итог. Чтобы игра «закрылась» по-настоящему, внутри если время игры равно 0 то останавливают интервалы и больше не рисуют.

Шаг 4. Враг догоняет: расстояние

В играх часто нужно «кто ближе». Расстояние между двумя точками на плоскости считается теоремой Пифагора — через корень суммы квадратов. квадратный корень и в степени уже есть в нашем словаре:

Команда квадратный корень — со скобкой сразу после имени, выражение целиком внутри её скобок.

Шаг 5. Сложность: скорость растёт

Игры становятся интереснее, когда усложняются. Простейший приём — ускорять врага с каждой поимкой:

Другие приёмы усложнения: больше врагов, меньше время, реже бонусы, случайные препятствия (интервал + округлить(математика-случайное число * N)).

Шаг 6. Каркас платформера

Бегалка с прыжком — движение по х постоянное, по у действует «гравитация»:

Гравитация — это «скорость_у растёт каждый кадр»; пол — «если упал ниже линии, останови». Платформа — ещё одно условие: если у больше 200 и х больше 100 и х меньше 200 то — стоять на ней.

Шаг 7. Идеи для собственных игр

• Догонялки: враг движется к герою — уменьшайте разницу координат

каждый кадр (см. Шаг 4);

• Собиратель: разбросайте «монеты» (целое случайное число), +

очко за касание;

• Уклонист: падают сверху препятствия (их у растёт в кадре),

игрок ходит по низу;

• Пинг-понг: мяч отскакивает от стен и от ракетки, промах —

поражение;

• Минное поле: сетка из контейнеров, под некоторыми мины

(округлить(математика-случайное число * 9) равно 0).

Для каждой игры порядок один: состояние → события → кадры → правила.

пер загаданное = ЦЗОП("Загадайте число")
пер попытка = ЦЗОП("Ваша догадка")
пер попыток = 0
пока попытка не равно загаданное то
	попыток = попыток + 1
	если попытка меньше загаданное то
		печать("больше")
	конец
	иначе
		печать("меньше")
	конец
	попытка = ЦЗОП("Ваша догадка")
конец
попыток = попыток + 1
печать("Угадал за " + попыток + " попыток")

пер машина = ЗОП("Ход компьютера")
пер игрок = ЗОП("Ваш ход")
если машина равно игрок то
	печать("Ничья")
конец
иначе если (машина равно "к" и игрок равно "н") или (машина равно "н" и игрок равно "б") или (машина равно "б" и игрок равно "к") то
	печать("Поражение")
конец
иначе
	печать("Победа!")
конец

содержание холста
пер х = 50
пер у = 50
пер очки = 0
пер секунд_осталось = 10
интервал(безимянная функция() начало
	х = округлить(математика-случайное число * 340) + 20
	у = округлить(математика-случайное число * 260) + 20
конец, 500)
при нажатии мышкой начало
	если позиция клика по x больше х и позиция клика по x меньше х + 40 и позиция клика по y больше у и позиция клика по y меньше у + 40 то
		очки = очки + 1
		печать("Поймал!")
	конец
конец)
интервал(безимянная функция() начало
	очистить холст
	цвет заливки зеленый
	нарисовать прямоугольник(х, у, 40, 40)
	цвет заливки черный
	размер шрифта текста "20px Arial"
	нарисовать текст("Очки: " + очки, 10, 25)
конец, 30)
интервал(безимянная функция() начало
	если секунд_осталось больше 0 то
		секунд_осталось = секунд_осталось - 1
	конец
	если секунд_осталось равно 0 то
		печать("Игра окончена! Очков: " + очки)
		секунд_осталось = -1
	конец
конец, 1000)

Дальше — Глава 19: сохранение и время. Игра запомнит ваш рекорд даже после закрытия.

Глава 19. Сохранение и время

Браузер умеет запоминать данные между запусками программы и знает текущее время. Это превращает игрушки в игры с рекордами, а программы — в ежедневники и таймеры.

Шаг 1. Локальное хранилище

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

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

В ячейке хранится текст: число 42 превратится в "42". Для вычислений его переводят обратно: преобразовать строку в число.

Шаг 2. Рекорд игры

Классическое применение — рекорд. Читаем старый рекорд (если его нет — считаем нулём), сравниваем с новым результатом:

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

Команда очистить ячейки стирает всё хранилище целиком — «новая игра»:

Шаг 3. Словарь в хранилище

Хранилище держит только текст, но словари спасают JSON-превращение из Главы 12: словарь → текст → хранилище → текст → словарь:

Так устроены настоящие сохранения игр: один ключ «сохранение» держит весь прогресс.

Шаг 4. Часы: сейчас и команды времени

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

День недели — число: 0 — воскресенье, 1 — понедельник и так далее. Научим программу здороваться по времени суток:

Шаг 5. Таймер на командах времени

время — большое растущее число миллисекунд. Разница двух замеров — сколько прошло. Засечём, сколько секунд заняли три печати:

Внимание на скобки: целое снизу (...)) — внутренняя скобка считает разницу, внешняя закрывает команду.

Шаг 6. Электронные часы

Часы, которые «тикают» сами, делаются интервалом из Главы 16 (в учебнике интервал работает на холсте — но в консоли тоже можно печатать):

Такой интервал печатает время раз в секунду — настенные часы в консоли.

пер имя = ЗОП("Как зовут игрока?")
локальное хранилище- добавить ячейку("игрок", имя)
пер изХранилища = локальное хранилище- прочитать ячейку("игрок")
печать("Игрок: " + изХранилища + " — записан в дневник")

пер годы = ЦЗОП("Сколько вам полных лет?")
печать(годы * 365)

пер секунда = 0
интервал(безимянная функция() начало
	секунда = секунда + 1
	если секунда остаток от деления на 2 равно 0 то
		печать("так " + секунда)
	конец
	иначе
		печать("тик " + секунда)
	конец
конец, 1000)

Дальше — Глава 20: свои библиотеки. Упакуем полезные команды в переиспользуемый набор.

Глава 20. Свои библиотеки

Библиотека — это набор готовых команд, который кто-то уже написал и упаковал для повторного использования. Вместо того чтобы каждый раз заново придумывать «случайное число между 10 и 50», вы подключаете библиотеку и пользуетесь готовым.

Шаг 1. Подключение библиотеки

Библиотека подключается одной строкой — ПБ (сокращение от «подключить библиотеку») — и обычно ставится в начало программы:

Подключённые команды становятся «своими»: пишутся как обычные команды РЯП. Учебник знает все встроенные библиотеки и несколько собственных (из папки библиотеки проекта: приветствие, удвоение, счет), а компилятор ryap.exe разворачивает их так же.

Шаг 2. Библиотека расширенной математики

Сравните целое_случайное_число(5, 1) с командой языка «целое случайное число до 5)»: библиотечная умеет задавать и нижнюю границу — например, кубик от 1 до 6 без прибавления единицы.

Шаг 3. Библиотека работы с холстом

Три команды, которыми мы пользовались вручную в главах 15–16, уже упакованы здесь:

Особый случай: размеры_холста(стандарт, стандарт) — растянуть холст на всё окно (внутри библиотеки слово «стандарт» — магическое значение 6.666, о котором знать не нужно).

Шаг 4. Библиотека работы с текстом

То же самое умеет разбить строку ("") из Главы 9 — но библиотека читается как команда, а не как хитрость со скобками.

Шаг 5. Своя библиотека — это свои функции

Секрет библиотек прост: это обычные функции, написанные кем-то раньше. Вот ваша собственная мини-библиотека для игр — просто функции в начале программы: