Переменные. Урок 5 курса «Программирование в Scratch»

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

Как раз эту задачу решают переменные. Переменная состоит из имени и значения. Значение – это и есть данные. Через имя переменной мы обращаемся к ячейкам памяти, чтобы получить оттуда данные или изменить их.

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

В Scratch ярко-оранжевый раздел «Переменные» содержит несколько блоков:

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

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

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

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

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

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

Команда «задать <переменной> значение …» записывает в указанную переменную те или иные данные. Например, число 10.

Команда «изменить <переменную> на …» в случае чисел изменяет значение переменной на указанную величину. То есть, если переменная содержала число 10, а мы дали команду изменить ее на 2, переменная будет хранить значение 12, а не 2.

Если же переменная содержала 10, а мы хотим присвоить ей значение 2, надо воспользоваться командой «задать <переменной> значение …».

Рассмотрим как работать с переменными на примере. Пусть в нашем проекте по сцене ходят два спрайта – кот и краб. Ходить они будут в разных направлениях, но с одинаковой скоростью.

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

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

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

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

Скрипт краба:

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

Когда выполняются команды «идти <скорость> шагов», то на место переменной «скорость» на самом деле подставляется ее значение. Например, число 10. В результате получается команда «идти 10 шагов», хотя мы этого не видим.

Более того, с помощью арифметических операций можно видоизменить нашу программу. Пусть краб ходит в два раза медленнее кота. То есть, если у кота скорость 10, у краба она должна быть 5. Если же у кота скорость 8, у краба она должна стать 4.

Для этого воспользуемся блоком с делением из зеленого раздела «Операции». Слева от знака деления поставим переменную «скорость», а справа – число 2.

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

Усложним нашу программу. Пусть значение переменной «скорость» задает пользователь. Если он нажмет на клавиатуре число 1, то скорость будет иметь значение 5, а если нажмет на клавиатуре число 2, скорость будет иметь значение 10. Если же человек нажмет 0, скорость должна установиться также в 0, то есть спрайты попросту остановятся.

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

Этот скрипт можно добавить любому спрайту.

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

Обратите внимание на форму блока, который содержит только имя переменной. Это прямоугольник со скругленными углами. Блоки подобной формы есть во многих разделах вкладки «Код». Например, в секции «Движение» это блоки «положение x», «положение y», «направление»:

Подобные блоки можно назвать встроенными в Scratch переменными. В них записываются значения, которые извлекаются из каких-нибудь объектов. Так в переменную «положение x» записывается значение текущей координаты x спрайта. Мы можем извлекать это значение и использовать его в программе.

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

Здесь мы используем переменную «положение x», чтобы проверить, находится кот справа или слева. Вспомним, что 0 – это середина холста. Налево идут значения меньше нуля, направо – больше.

Задание

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

PDF-версия курса и android-приложение включают три дополнительных урока («Списки», «Функции», «Работа со звуком»), а также ответы к заданиям.

переменная

переменная , встроенная команда Tcl, начиная с версии 8.0, объявляет и при необходимости устанавливает переменные в пространстве имен.

См. также

константы

Включает информацию о переменных только для чтения.

set

Считывает или присваивает значение переменной.

namespace upvar

Дает переменной в одном пространстве имен имя на текущем уровне.

upvar

Связывает переменную более высокого уровня с переменной текущего уровня.

переменная и глобальная

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

Переменные в TclOO

Обсуждает переменную, переменную oo::define, переменную oo::objdefine и мою переменную в TclOO имя значение… ? имя ? значение ?

Документация

официальная ссылка

Описание

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

имя может быть именем массива, но не переменной в массиве.

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

 eval one {
    переменное приветствие привет
}
set one::greeting ;#-> hello 

Переменная может быть объявлена, но не установлена:

 namespace which -variable hello; #-> ::привет
пространство имен which -variable goodbye; #-> <пустая строка} 

В процедуре переменная привязывает переменную пространства имен к тому же имени на уровне процедуры:

 процедура ч1 {} {
    имя переменной Приам
}
p1 ;#-> Приам
пространство имен eval n1 {
    имя переменной Гектор
}
оценка пространства имен n2 {
    процесс p2 {} {
        переменная ::n1::имя
                Имя набора
    }
}
n2::p2 ;#-> hector 

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

 global foo bargrill 

требуется несколько вызовов переменной:

 variable foo; переменная полоса; переменная гриль 

В следующем примере пространство имен, которое идентифицирует ::bar::a, но внутри foo::p1, переменная разрешается в ::foo::bar::a, которого не существует:

 пространство имен eval ::bar {переменная a 1}
пространство имен eval ::foo {
    помещает [список {bar::a разрешается в} [пространство имен, которое -переменная bar::a]]
    процесс p1 {} {
        переменная bar::a
        ставит $а
    }
}
::foo::p1 ;# ->  не удается получить доступ к "bar::a": родительское пространство имен не существует 

set ищет существующую переменную так же, как пространство имен, которое делает -variable, и выбирает существующую переменную если доступно. Напротив, переменная просто прикрепляет текущее пространство имен к предоставленному $name, чтобы сделать его полностью определенным.

Обсуждение

escargo 04.09.2003: В поведении URL в текстовом виджете есть некоторые идиомы кода, с которыми я не знаком. Один из них:

 переменная {} 

Какого черта это должно делать ?

DGP, PYK: То, что говорят документы. Он связывает переменную с именем [namespace current]:: . Обратите внимание, что хвост пространства имен [текущее пространство имен]:: — это пустая строка.

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

 комплект (элемент1) 1
набор (элемент2) 2
если {$(элемент1) > $(элемент2)} {
    установить больший элемент1
} еще {
    установить больший элемент2
}
ставит "Больше $($больше)" 

escargo 05.09.2003: Боже, вау. Не только все является строкой, но и ничто является строкой. RS: "Все" включает "ничего"...

KJN: 2004-08-12: Я пришел сюда в поисках объяснения этой необычной идиомы, и я рад его найти!

До сих пор я не осознавал, что минимальное количество символов в имя равно нулю! (Это где-нибудь упоминается в руководстве?) Даже без оператора переменной

можно написать:

 set {} 12
помещает ${} ;# -> 12
set {} ;# -> 12 

Пустая строка является приемлемым именем для процедур:

 proc {} a {
    ставит $а
    вернуть $а
}
{} 42 

, который выводит 42 на стандартный вывод и возвращает 42.

RS: Для скалярных переменных и команд вам по-прежнему нужно ограничивать «ничего» кавычками или фигурными скобками, но с именами массивов этого недостаточно. В документации Tcl сказано:

 $''name''(index) 

name — имя переменной массива, а index — имя элемента в этом массиве. Имя должно содержать только буквы, цифры, знаки подчеркивания и разделители пространств имен, , и может быть пустой строкой . Отсюда объяснение синтаксиса $(key) DGP.

---

Досси и Гельмут Гизе недавно обсуждали переменную на comp.lang.tcl. Досси отвечает на замечание Хельмута:

 Итак, вы должны различать «создание» переменной и
«определение» его. В вашем примере вы _create_ 'foo::bar', но не
_определить_ это. Следовательно, [информация существует] ее не видит, как сказано в книге. 

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

PYK 28-02-2015, 15-10-2019: "Объявить" для этого лучше, чем "создать". информация существует, было бы более подходящим названием info set:

 % namespace eval foo {
    процедура foo {} {
        переменная myarr
        упвар какой-то мьярр
        пари мойарр
    }
    процедура foo2 {} {
        переменная myarr
        пространство имен which -переменная myarr
    }
    процедура foo3 {} {
        переменная myarr
        информация существует
    }
}
% фу:: фу
"myarr" не является массивом
% установить somearr(x) y
у
% фу:: фу
myarr (x) = y
% фоо:: фоо2
::foo::myarr
% фоо:: фоо3
0 9" во всей краткости» можно написать: 
 
 набор массивов [переменная foo] { это инициализирует {}, а не foo! } 
 вместо:
 переменная foo
    набор массивов foo { это действительно инициализирует foo } 
, который работает и предназначен; в отличие от:
 имя переменной {это словарь/список, а не массив}
 
  Earnie - 2018-06-16 13:58:27 
 @m7j4k9 Возможно, я вижу следующий синтаксис того, что вы предлагаете: с теми же принципами, что и набор массивов, в сочетании с принципами переменной.
 PYK 2021-07-28: Во всяком случае, переменная должна возвращать значение, на которое установлена ​​переменная.
 Page Authors 
 pyk
 rs
 Tcl syntax
 Arts and Crafts of Tcl-Tk Programming
 Category Command
 Category Glossary
 7 Ways to Посмотрите на значения переменных во время отладки в Visual Studio 
 Аарон Холберг
 15 июля 2016 г.  1 0
 Когда вы запускаете свой код и что-то ведет себя неожиданно, как вы узнаете, что идет не так? Когда я учился в школе, первый способ, которым я научился отлаживать шаткое приложение, заключался в том, чтобы вставлять операторы «print()» повсюду, запускать свой код и просматривать журнал вывода, чтобы увидеть, заметил ли я, что что-то выглядит не так. . Затем, если бы я хотел посмотреть значение другой переменной, мне пришлось бы добавить новый оператор «print()», перекомпилировать и снова запустить приложение. Это может быть утомительным процессом, поэтому я рад сообщить вам, что есть лучший способ, чем засорять ваш код множеством операторов «print()», которые вам придется удалить позже. Вы можете использовать инструменты отладчика Visual Studio для проверки переменных на лету.
 В этом посте я рассмотрю семь различных способов проверки значений переменных при отладке кода в отладчике Visual Studio без изменения кода. Какие способы вы уже используете? Дайте нам знать в комментариях ниже.
 Если вы хотите оставить отзыв о наших будущих идеях, помогите нам улучшить отладчик Visual Studio, присоединившись к нашему сообществу.
  
 Для просмотра значений переменных во время отладки сначала необходимо перейти в режим приостановки. Вы можете быть остановлены в точке останова, остановлены во время пошагового выполнения или даже остановлены в исключении, и тогда у вас будет доступ к значениям ваших переменных с помощью этих методов.
  Наведите указатель мыши на переменную, чтобы увидеть ее значение. 
 Наиболее часто используемым способом просмотра переменных является всплывающая подсказка. При остановке в отладчике наведите курсор мыши на переменную, которую хотите просмотреть. Появится всплывающая подсказка, показывающая значение этой переменной. Если переменная является объектом, вы можете развернуть объект, щелкнув стрелку, чтобы увидеть элементы этого объекта.
 Вы также можете «прикрепить» всплывающую подсказку к своему коду, щелкнув значок булавки рядом со значением. Таким образом, вы можете увидеть изменение значения прямо в коде по мере его прохождения. Это может пригодиться при отладке внутри циклов, когда вы наблюдаете постоянное изменение одного значения.
  
 ** См. переменные, используемые рядом с указателем инструкции. **
 Когда вы останавливаетесь в разных местах вашего кода, окно Autos автоматически заполняется всеми переменными, используемыми в текущем операторе (строка, где находится желтый указатель инструкции) и некоторыми окружающими операторами. Объем переменных, которые автоматически заполняются из окружающих операторов, зависит от отлаживаемого языка. Как правило, вы увидите переменные, на которые ссылаются на 3 строки позади и на 1 строку впереди текущего оператора. Некоторые языки, такие как JavaScript, не поддерживаются окном Autos.
 Откройте это окно из окна Debug/Windows/Autos (Ctrl+Alt+V, A)
 **Просмотрите переменные, которые существуют в локальной области вашего текущего кадра стека. **
 Окно Locals будет заполнено локальными переменными для текущего метода, которые имеют. Как и в окне Autos, отображаемые здесь переменные заполняются автоматически. Решение о том, какое окно вы предпочитаете использовать, зависит от того, какую область переменных вы хотели бы видеть.
 Во всех наших окнах переменных при изменении любых значений переменных новые значения будут отображаться красным текстом.
 Откройте это окно из окна Debug/Windows/Locals (Ctrl+Alt+V, L).
  Вычисление переменных и **  выражений   и отслеживание результатов. **
 Доступно четыре окна Watch. Эти окна начинаются пустыми и позволяют вам добавлять имена переменных, за которыми вам нужно следить во время отладки вашего приложения. Вы можете щелкнуть редактируемую строку под столбцом имени и ввести имя переменной, значение которой вы хотите просмотреть. Или вы можете щелкнуть правой кнопкой мыши переменные в редакторе кода и выбрать «Добавить в список».
 Помимо добавления одной переменной, вы можете ввести вообще любое выражение. Таким образом, вы потенциально можете вызывать методы, вычислять лямбда-выражения или просто делать что-то вроде «1+3». Обратите внимание, что при вводе выражения, выполняющего код, могут возникать побочные эффекты, изменяющие состояние вашего приложения.
 Откройте эти окна из Debug/Windows/Watch (Ctrl+Alt+W, 1).
 **Быстро проверьте значение и свойства одной переменной или выражения в одноразовом всплывающем окне диагностики. **
 Окно QuickWatch — это диалоговое окно, которое можно использовать для проверки одной переменной или выражения. Это временное диалоговое окно удобно использовать, когда вам нужно больше места для проверки всех свойств объекта, но вы не хотите изменять макет окна.
 Откройте окно QuickWatch, щелкнув правой кнопкой мыши переменную и выбрав «QuickWatch…» или используя сочетание клавиш Shift+F9.
  Просмотр значения переменной или выражения одновременно в нескольких потоках или рекурсивных вызовах. 
 Для использования доступны четыре окна Parallel Watch. Как и в окнах Watch, вы можете щелкнуть редактируемую строку и ввести имя переменной или выражение, значение которого вы хотите просмотреть.
 Каждая строка в окне идентифицирует отдельный поток, поэтому вы можете видеть значение одной и той же переменной во всех ваших текущих потоках.
 Он также покажет вам значение переменной в рекурсивном стеке в том же потоке, где каждая строка представляет собой итерацию вызова этой функции.
 Откройте эти окна из Debug/Windows/Parallel Watch (Ctrl+Shift+D, 1).