Как сделать переменную
Обновлено: 03.07.2024
Переменная - это некий контейнер, в котором VBA хранит данные. Если подробнее, то это как коробочка, в которую Вы можете положить что-то на хранение, а затем по мере необходимости достать. Только в данном случае в переменной мы храним число, строку или иные данные, которые затем можем извлекать из неё и использовать в коде по мере необходимости.
Для чего нужна переменная? Чтобы хранить значение и применить его позже в любой момент. Например, в ячейке А1 записана сумма, а нажатием на кнопку запускается обновление отчета. После обновления отчета сумма в А1 изменится. Необходимо сверить сумму до обновления с суммой после и в зависимости от этого сделать какое-либо действие. Переменная как раз позволит запомнить значение ячейки до того, как она обновится и использовать именно это значение после обновления.
Требования к переменным:
В качестве имен переменных можно использовать символы букв и числа, но первой в имени переменной всегда должна быть буква. Не допускается использование точки, запятой, пробела и иных знаков препинания, кроме нижнего подчеркивания. Длина имени не должна превышать 254 символов. Так же нельзя использовать в качестве имен для переменных зарезервированные константы редактора VBA(например Sub, Msgbox, ubound, Date и т.п.). Так же для переменных неважен регистр букв.
Теперь рассмотрим основные декларированные в VBA типы данных, которые можно хранить в переменных:
Как видно из таблицы больше всего памяти занимает Variant . Притом это если он хранит числовые данные. Если же такая переменная будет хранить данные строкового типа(текст), то размер занимаемой памяти будет измеряться уже начиная с 22 байт + длина строки, хранящейся в переменной. Чем больше памяти занимает переменная, тем дольше она инициализируется в памяти и тем медленнее код будет выполняться. Вот поэтому и важно явно задавать тип данных, хранимых в переменной - это называется объявить переменную.
Тип данных Decimal больше не используется, поэтому объявить переменную данного типа в VBA не получится - подобная попытка приведет к синтаксической ошибке. Для работы с данными типа Decimal переменную необходимо изначально объявить как Variant или вообще без типа (например Dim a), т.к. тип данных Variant используется в VBA по умолчанию и принимает любой тип данных.
Так же переменным можно назначать и другие типы данных, которых нет в таблице выше - это типы, которые поддерживаются объектной моделью приложений, к которым "подключен" VBA. Например, если зайти в VBA из Excel, то библиотека типов объектной модели Excel подключена по умолчанию и для переменных становится доступно множество типов этой объектной модели. Многие из них знакомы всем: Workbook, Worksheet, Range, Cells, Chart и т.д. Т.е. это книги, листы, ячейки, диаграммы. Типов много, почти на каждый объект и коллекцию. Рассматривать здесь все бессмысленно. Могу лишь привести пару строк кода:
Dim rRange as Range 'назначили переменной тип ячейка/диапазон Set rRange = Range("A1") 'присвоили ссылку на ячейку A1 текущего листа
Про объявление переменных подробно написано чуть ниже.
А более подробно про обращение к диапазонам из VBA можно почитать в этой статье: Как обратиться к диапазону из VBA
как объявлять переменные
На самом деле все очень просто. Это делается при помощи операторов области действия: Dim , Public , Static и оператора присвоения типа As . Самый распространенный оператор - Dim . Его и возьмем в качестве примера. Синтаксис объявления:
[оператор области действия] Имя_переменной As [тип данных]
Очень частая ошибка при объявлении переменных, совершаемая начинающими изучать VBA:
Dim MyVar1, MyVar2, MyVar3 As Integer
Вроде бы исходя из логики всем переменным присвоен тип данных Integer . Но это ошибочное суждение. Тип Integer присвоен только последней переменной, к которой он "привязан" оператором As - MyVar3. Все остальные переменные имеют тип данных Variant . Т.е. если Вы не задаете каждой переменной свой тип хранимых данных явно(т.е. не указываете для неё тип данных через As), то VBA сам присваивает для такой переменной тип данных Variant , т.к. он может хранить любой тип данных. А вот так выглядит правильное присвоение типа данных:
Dim MyVar1 As Integer, MyVar2 As Integer, MyVar3 As Integer
Это и есть объявление переменных. Т.е. сначала идет оператор области действия ( Dim , Public , Static ), сразу за ним имя переменной, затем оператор As и тип.
Но это не все. Некоторые типы переменным можно присваивать еще короче - даже без оператора As :
Dim MyVar1%, MyVar2%, MyVar3%
Теперь разберемся с операторами области действия( Dim , Public и Static ):
- Dim - данный оператор используется для объявления переменной, значение которой будет храниться только в той процедуре, внутри которой данная переменная объявлена. Во время запуска процедуры такая переменная инициализируется в памяти, Вы можете использовать её значение внутри только этой процедуры и по завершению процедуры переменная выгружается из памяти(обнуляется) и данные по ней теряются. Переменную, объявленную подобным образом еще называют локальной переменной. Однако с помощью данного оператора можно объявить переменную, которая будет доступна в любой процедуре модуля. Необходимо объявить переменную вне процедуры - в области объявлений(читать как первой строкой в модуле, после строк объявлений типа - Option Explicit ). Тогда значение переменной будет доступно в любой процедуре лишь того модуля, в котором данная переменная была объявлена. Такие переменные называются переменными уровня модуля.
- Static - данный оператор используется для объявления переменной, значение которой предполагается использовать внутри процедуры, но не теряя значения данной переменной по завершении процедуры. Переменные данного типа обычно используют в качестве накопительных счетчиков. Такая переменная инициализируется в памяти при первом запуске процедуры, в которой она объявлена. По завершении процедуры данные по переменной не выгружаются из памяти, но однако они не доступны в других процедурах. Как только Вы запустите процедуру с этой переменной еще раз - данные по такой переменной будут доступны в том виде, в котором были до завершения процедуры. Выгружается из памяти такая переменная только после закрытия проекта(книги с кодом). В простонародье такие переменные чаще называют глобальными(возможно из-за того, что раньше подобные переменные объявлялись при помощи оператора Global, который в настоящее время устарел и не используется)
- Public - данный оператор используется для объявления переменной, значение которой будет доступно в любой процедуре проекта(в обычных модулях, модулях класса, модулях форм, модулях листов и книг). Переменная, объявленная подобным образом, должна быть объявлена вне процедуры - в области объявлений. Такая переменная загружается в память во время загрузки проекта(при открытии книги) и хранит значение до выгрузки проекта(закрытия книги). Использовать её можно в любом модуле и любой процедуре проекта. Важно: объявлять подобным образом переменную необходимо строго в стандартном модуле. Такие переменные называются переменными уровня проекта.
Для большего понимания того, где и как объявлять переменные уровня проекта два небольших примера.
Неправильное объявление
Option Explicit Sub main() Public MyVariable As String MyVariable = "Глобальная переменная" 'показываем текущее значение переменной MsgBox MyVariable 'пробуем изменить значение переменной Call sub_main 'показываем измененное значение переменной MsgBox MyVariable End Sub 'доп.процедура изменения значения переменной Sub ChangeMyVariable() MyVariable = "Изменили её значение" End Sub
переменные не будут видны во всех модулях всех процедур и функций проекта, потому что:
1. Оператор Public недопустим внутри процедуры(между Sub и End Sub), поэтому VBA при попытке выполнения такой процедуры обязательно выдаст ошибку - Invalid Attribut in Sub or Function.
2. Даже если Public заменить на Dim - это уже будет переменная уровня процедуры и для других процедур будет недоступна.
3. Т.к. объявление неверное - вторая процедура( ChangeMyVariable ) ничего не знает о переменной MyVariable и естественно, не сможет изменить именно её.
Правильное объявление
'выше глобальных переменных и констант могут быть только декларации: Option Explicit 'принудительное объявление переменных Option Base 1 'нижняя граница объявляемых массивов начинается с 1 Option Compare Text 'сравнение текста без учета регистра 'глобальная переменная - первой строкой, выше всех процедур Public MyVariable As String 'далее процедуры и функции Sub main() MyVariable = "Глобальная переменная" 'показываем текущее значение переменной MsgBox MyVariable, vbInformation, "www.excel-vba.ru" 'пробуем изменить значение переменной Call ChangeMyVariable 'показываем измененное значение переменной MsgBox MyVariable, vbInformation, "www.excel-vba.ru" End Sub 'доп.процедура изменения значения переменной Sub ChangeMyVariable() MyVariable = "Изменили её значение" End Sub
Как правильно назвать переменную:
"Что самое сложное в работе программиста? - выдумывать имена переменным." :-) А ведь придумать имя переменной тоже не так-то просто. Можно, конечно, давать им имена типа: a, d, f, x, y и т.д.(я сам иногда так делаю, но либо в простых кодах, либо для специального запутывания кода). Но стоит задуматься: а как Вы с ними будете управляться в большом коде? Код строк на 10 еще потерпит такие имена, а вот более крупные проекты - не советовал бы я в них оперировать такими переменными. Вы сами запутаетесь какая переменная как объявлена и какой тип данных может хранить и что за значение ей присвоено. Поэтому лучше всего давать переменным осмысленные имена и следовать соглашению об именовании переменных. Что за соглашение? Все очень просто: перед основным названием переменной ставится префикс, указывающий на тип данных, который мы предполагаем хранить в данной переменной. Про имеющиеся типы данных я уже рассказал выше. А ниже приведена примерная таблица соответствий префиксов типам данных:
| Префикс | Тип хранимых данных |
|---|---|
| b | Boolean |
| bt | Byte |
| i | Integer |
| l | Long |
| s | Single |
| d | Double |
| c | Currency |
| dt | Date |
| str | String |
| obj | Object |
| v | Variant |
Лично я немного для себя её переделал, т.к. некоторые обозначения мне кажутся скудными. Например Double я обозначаю как dbl, а Single как sgl. Это мне кажется более наглядным.
В чем еще плюс явного указания префикса данных. В VBA есть такие операторы как Def, при помощи которых можно указать тип данных по умолчанию для переменных, первая буква имени которых попадает в заданный в операторе диапазон. Например:
DefBool B Sub test() Dim bCheck End Sub
Автоматически переменной bCheck будет присвоен тип Boolean, т.к. она начинается с буквы b - регистр здесь не имеет значения(впрочем как в VBA в целом). Оператор Def задается в области объявления. Можно задать не одну букву, а целый диапазон букв:
DefBool B-C Sub test() Dim bCheck, cCheck End Sub
Но я считаю, что одной буквы для одного типа вполне достаточно. Можно задать сразу несколько операторов Def.
DefBool B DefStr S Sub test() Dim bCheck, sCheck End Sub
Ниже приведен полный перечень операторов типов и данные, которые задает каждый из них:
DefBool - Задает тип Boolean
DefByte - Задает тип Byte
DefCur - Задает тип Currency
DefDate - Задает тип Date
DefDbl - Задает тип Double
DefInt - Задает тип Integer
DefLng - Задает тип Long
DefObj - Задает тип Object
DefSng - Задает тип Single
DefStr - Задает тип String
DefVar - Задает тип Variant
По умолчанию в VBA применена инструкция DefVar для всех переменных.
Ну и немаловажный момент это непосредственно осмысленное имя переменной. Имя переменной должно примерно отражать то, что в ней будет храниться. Например, Вы создаете отчет и Вам надо объявить две переменные: одна имя листа, другая имя книги. Можно было сделать так: str1, str2. Коротко, здорово. Но если подумать - и как можно понять, какая из этих переменных что хранит? Никак. Надо просматривать код и вспоминать, какой переменной какое значение было присвоено. Не совсем удобно, правда? А если бы Вы задали имена так: strBookName, strSheetName, то вроде как более понятно, что мы в них будем хранить.Это удобно не только вам самим при работе с кодом, но и другим людям, которые, возможно в будущем будут пользоваться Вашим кодом. Им будет удобнее читать код, если он будет оформлен грамотно, а переменные названы осмысленно. И не стоит экономить на длине имени - имя должно быть понятным. Без фанатизма, конечно :-). Хоть VBA и позволяет нам создавать переменные длиной до 254 символов, но читать такую переменную так же неудобно, как и с одним символом. Но здесь уже все зависит от Ваших предпочтений и фантазии.
Небольшое дополнение: лучше привыкать давать названия переменным на латинице(т.е. английский алфавит), т.к. для VBA английский язык "родной" и лучше использовать его.
Небольшой пример использования переменных в кодах:
Просмотреть пошагово выполнение данного кода поможет статья: Отлов ошибок и отладка кода VBA
Важно! Назначение значений переменным задается при помощи знака равно(=). Однако, есть небольшой нюанс: для переменных типа Object (а так же других объектных типов(Workbook, Worksheet, Range, Cells, Chart и т.п.)) присвоение идет при помощи ключевого оператора Set :
'присвоили переменной rRange ссылку на текущую выделенную ячейку Set rRange = Selection
это так же называется присвоением ссылки на объект. Почему именно ссылки? Все просто: при помещении в переменную непосредственно ячейки или диапазона( Set var = Range("A1") или Set rRange = Selection ) нет никакого запоминания самой ячейки. В переменную помещается лишь ссылка на эту ячейку(можете считать, что это как ссылка в формулах) со всеми вытекающими: такое назначение не запоминает свойства ячейки до или после - в переменной хранится ссылка на конкретную ячейку и доступ есть исключительно к свойствам ячейки на текущий момент. Чтобы запомнить для этой ячейки значение, цвет или даже адрес (а так же и другие свойства) до её изменения и применить запомненное даже после изменения/перемещения самой ячейки - необходимо запоминать в переменные именно свойства ячейки:
Sub main() Dim val, l_InteriorColor As Long, l_FontColor As Long Dim rRange As Range 'назначили переменной тип ячейка/диапазон 'присвоили переменной rRange ссылку на активную ячейку Set rRange = ActiveCell 'запоминаем свойства ячейки val = rRange.Value 'значение l_InteriorColor = rRange.Interior.Color 'цвет заливки l_FontColor = rRange.Font.Color 'цвет шрифта 'копируем другую ячейку и вставляем на место активной ActiveSheet.Range("D1").Copy rRange 'проверяем, что rRange теперь имеет совершенно другие свойста - как у D1 MsgBox "Значение rRange: " & rRange.Value & vbNewLine & _ "Цвет заливки rRange: " & rRange.Interior.Color & vbNewLine & _ "Цвет шрифта rRange: " & rRange.Font.Color & vbNewLine, vbInformation, "www.excel-vba.ru" 'назначаем свойства из сохраненных в переменных rRange.Value = val 'значение rRange.Interior.Color = l_InteriorColor 'цвет заливки rRange.Font.Color = l_FontColor 'цвет шрифта 'проверяем, что rRange возвращены параметры до копирования MsgBox "Значение rRange: " & rRange.Value & vbNewLine & _ "Цвет заливки rRange: " & rRange.Interior.Color & vbNewLine & _ "Цвет шрифта rRange: " & rRange.Font.Color & vbNewLine, vbInformation, "www.excel-vba.ru" End Sub
Это так же распространяется на все другие объекты. Т.е. те переменные, значения которым назначаются через оператор Set.
Для других же типов Set не нужен и в переменную значение заносится без этих нюансов.
Константы
Так же есть и иной вид "переменных" - константы. Это такая же переменная, только(как следует из её названия) - она не может быть изменена во время выполнения кода, т.к. является величиной постоянной и значение её назначается только один раз - перед выполнением кода.
Const sMyConst As String = "Имя моей программы"
Константам могут быть назначены данные тех же типов, что и для переменных, за исключением типа Object, т.к. Object это всегда ссылка на объект, который как правило обладает "динамическими"(т.е. обновляющимися) свойствами. А изменение для констант недопустимо.
Для дополнительной области видимости/жизни констант используется только Public . Если область видимости не указана, то константа будет доступна только из того модуля, в котором объявлена. Здесь обращаю внимание на то, что Dim уже не используется, т.к. Dim это идентификатор только для переменных. Пару важных отличий объявления констант от объявления переменных:
- при объявлении константы необходимо обязательно указывать явно, что это константа ключевым словом Const
- сразу в момент объявления необходимо назначить константе значение: = "Имя моей программы"
Во всем остальном объявление и применение констант идентично объявлению переменных. Коротко приведу пару примеров.
Если константа объявлена внутри процедуры:
то она не может быть использована в другой процедуре:
Чтобы использовать одну константу во всех процедурах модуля(того, в котором она объявлена), необходимо объявить её в области объявлений:
Чтобы использовать одну константу во всех процедурах проекта(книги), необходимо объявить её как Public:
Подробнее можно прочитать выше - как я уже писал для констант применяются те же правила, что и для переменных.
Мы уже знаем, что переменные, объявленные внутри блока, называются локальными. Они имеют локальную область видимости (используются только внутри блока, в котором объявлены) и автоматическую продолжительность жизни (создаются в точке определения и уничтожаются в конце блока).
Определение глобальных переменных
Подобно тому, как переменные во внутреннем блоке скрывают переменные с теми же именами во внешнем блоке, локальные переменные скрывают глобальные переменные с одинаковыми именами внутри блока, в котором они определены. Однако с помощью оператора разрешения области видимости ( :: ), компилятору можно сообщить, какую версию переменной вы хотите использовать: глобальную или локальную. Например:
Результат выполнения программы:
Global value: 3
Local value: 9
Ключевые слова static и extern
В дополнение к области видимости и продолжительности жизни, переменные имеют еще одно свойство — связь. Связь переменной определяет, относятся ли несколько упоминаний одного идентификатора к одной и той же переменной или нет.
Переменная без связей — это переменная с локальной областью видимости, которая относится только к блоку, в котором она определена. Это обычные локальные переменные. Две переменные с одинаковыми именами, но определенные в разных функциях, не имеют никакой связи — каждая из них считается независимой единицей.
Переменная, имеющая внешние связи, называется внешней переменной. Она может использоваться как в файле, в котором определена, так и в других файлах.
Если вы хотите сделать глобальную переменную внутренней (которую можно использовать только внутри одного файла) — используйте ключевое слово static:
Основной способ сохранения информации в ходе выполнения программы PHP состоит в использовании переменных; этот способ предусматривает выбор некоторого имени переменной и привязку к нему того значения, которое потребуется в процессе дальнейшего выполнения программы.
Ниже приведены наиболее важные сведения о переменных в языке PHP, которые следует знать:
Все переменные в языке PHP обозначаются префиксом в виде знака доллара ($).
Значением переменной является значение, присвоенное ей в последней по времени операции присваивания.
Присваивание значений переменным осуществляется с помощью операции присваивания; при этом переменная должна находиться слева от знака операции присваивания (=), а вычисляемое выражение — справа.
Переменные могут быть объявлены перед присваиванием им значений, но такое требование не является обязательным.
Переменные не имеют связанного с ними типа, отличного от типа своего текущего значения.
Переменные, используемые до того, как им будет присвоено значение, имеют значения, заданные по умолчанию.
Имена всех переменных в языке PHP начинаются с префикса в виде знака $. Остальная часть имен переменных, находящаяся за начальным префиксом $, должна состоять из букв в коде ASCII (прописных и строчных), цифр (0-9) и символов подчеркивания (_). Кроме того, первым символом после знака $ не должна быть цифра.
Присваивание значений переменным
Операция присваивания значения переменной очень проста — достаточно лишь написать имя переменной, ввести после него один знак равенства (=), затем ввести выражение, значение которого требуется присвоить переменной:
Следует учитывать, что переменной присваивается результат выражения, а не само выражение. Например, после присваивания значения с помощью приведенного выше оператора невозможно определить, что значение, присвоенное переменной $pi, было получено путем сложения двух чисел.
Вполне возможно, что в программе фактически потребуется вывести на внешнее устройство приведенное математическое выражение, а не вычислять его значение. Программист может вынудить интерпретатор PHP рассматривать оператор присваивания переменной результата математического вычисления как оператор присваивания строкового значения, заключив это выражение в кавычки:
Переменные в языке PHP не имеют связанных с ними типов, поэтому в отношении переменной, приведенной в тексте программы, нельзя узнать заранее, будет ли она использоваться для хранения числа или строки символов. Как же в этом случае можно определить, какое заданное по умолчанию значение должна иметь переменная, если ей еще не присвоено значение?
Ответ на этот вопрос состоит в том, что тип переменной с неприсвоенным значением (как и в случае переменной с присвоенным значением) интерпретируется в зависимости от контекста, в котором используется эта переменная. В той ситуации, когда ожидается появление числа, вырабатывается число; аналогичный принцип применяется в отношении символьных строк. В любом контексте, в котором переменная рассматривается как число, переменная с неприсвоенным значением рассматривается как имеющая значение 0, а в любом контексте, в котором ожидается строковое значение, переменная с неприсвоенным значением рассматривается как имеющая в качестве значения пустую строку (строку длиной нуль символов).
Поскольку язык PHP не предъявляет такого требования, чтобы переменной было обязательно присвоено значение перед ее использованием, в некоторых ситуациях можно фактически изменять код выполнения программы, избирательно присваивая или не присваивая значение переменной! В языке PHP предусмотрена функция IsSet, которая проверяет переменную для определения того, было ли этой переменной присвоено значение.
Как показано в приведенном ниже коде, переменную с неприсвоенным значением можно отличить даже от переменной, которой было присвоено значение, предусмотренное по умолчанию:
Безусловно, на первый взгляд это может показаться странным, но приведенный выше код вырабатывает следующий результат:
Проверка присвоено ли значение переменной или нет
Переменной $unset никогда еще не присваивалось значение, поэтому она вырабатывает нулевое значение, когда ожидается число (как в проверке со сравнением на равенство, которое показывает, что две рассматриваемые переменные имеют одинаковое значение). Тем не менее функция IsSet позволяет провести различие между переменными $set и $unset.
Область определения переменной
— это формальный термин, используемый при формулировке правил, касающихся того, в каких ситуациях некоторое имя (скажем, переменной или функции) имеет один и тот же смысл в разных местах и в каких ситуациях два полностью совпадающих имени фактически ссылаются на разные объекты.
Любая переменная PHP, не заданная в функции, имеет глобальную область определения, и действие переменной распространяется за пределы данного конкретного "потока" выполнения. Иными словами, если какой-то переменной присваивается значение в начале файла сценария PHP, то переменная с этим именем сохраняет одно и то же значение в ходе обработки остальной части файла сценария, и если переменной не присваивается какое-то другое значение, то она сохраняет прежнее значение до конца сеанса выполнения данного кода (исключением являются переменные с теми же именами, находящиеся в теле функций).
Ниже показан расширенный пример использования глобальных и локальных переменных, показывающий их различия между собой:
Глобальные переменные внутри функций следует использовать в редких случаях, поскольку легко изменить значение переменной по ошибке, не предусмотрев последствий. Ошибки такого типа бывает очень сложно обнаружить.
Статические переменные – это переменные, которые не исчезают после завершения функции. Значение статической переменной можно снова использовать при следующем вызове функции – она по-прежнему будет иметь то же значение, которое получила при последнем вызове функции. Проще всего считать такую переменную глобальной, но доступной только для данной функции. Статическая переменная объявляется с помощью ключевого слова static:
В результате исполнения этого фрагмента будет выведено:
Использование статической переменной
Для предоставления информации об окружении, в котором работает PHP-сценарий, PHP использует специальные переменные, которые называются суперглобальными (super globals). Эти переменные не нужно объявлять как глобальные, они автоматически становятся общедоступными и содержат важные сведения об окружении сценария, например данные, полученные от пользователя.
Примером суперглобальной переменной может служить $_SERVER["PHP_SELF"]. Эта переменная содержит имя исполняемого сценария и входит в состав массива $_SERVER:
Использование переменной PHP_SELF
Суперглобальные переменные обеспечивают удобный способ доступа к информации об окружении сценария – от настроек сервера до введенных пользователем данных.
Константы
В программе вы можете определять константы. Значение константы, как следует из ее названия, не может изменяться во время исполнения программы. Константы определяют с помощью функции define(), которой в первом аргументе передается имя константы, а во втором – ее значение. Константы имеют глобальную область видимости и могут принимать значение любого элементарного (скалярного) типа данных, например строки или числа.
Чтобы получить значение константы, достаточно просто обратиться к ее имени или воспользоваться функцией constant. В отличие от переменных, перед именем константы знак доллара ($) не ставится.
Если имя константы хранится в переменной или возвращается функцией, то чтобы получить значение константы, необходимо воспользоваться функцией constant(имя_константы). Эта функция получает имя константы в качестве аргумента и возвращает ее значение. Кроме того, с помощью функции get_defined_constants() можно получить список (в виде массива) всех определенных вами констант.
Отличия констант и переменных:
в именах констант принято использовать только заглавные буквы;
имена констант не начинаются со знака доллара ($);
определить константу можно только с помощью функции define, а не простым оператором присваивания;
константы определяются и доступны глобально;
после объявления константу нельзя переопределить или отменить;
константы могут иметь только скалярные значения (числа и строки).
В примере ниже показан порядок использования констант:
Использование констант в программе
Этот код дважды выведет значение константы HELLO . В константе полезно хранить значение, которое должно оставаться неизменным, например путь к файлу настроек.
При объявлении переменных обычно используется оператор Dim. Оператор объявления может быть помещен внутрь процедуры для создания переменной на уровне процедуры. Или он может быть помещен в начале модуля в разделе объявлений, чтобы создать переменную на уровне модуля.
В примере ниже создается переменная и указывается тип данных "String".
Если данный оператор отображается в процедуре, переменная strName может использоваться только в этой процедуре. Если же оператор отображается в разделе объявлений модуля, переменная strName доступна для всех процедур данного модуля, но недоступна для процедур других модулей проекта.
Чтобы предоставить доступ к переменной всем процедурам проекта, перед ней нужно поставить оператор Public, как показано в примере ниже:
Дополнительные сведения об именовании переменных см. в статье Правила именования в Visual Basic.
Переменные могут быть объявлены одним из следующих типов данных: Boolean, Byte, Integer, Long, Currency, Single, Double, Date, String (для строк переменной длины), String * length (для строк фиксированной длины), Object или Variant. Если тип данных не указан, по умолчанию присваивается тип Variant. Вы также можете создать определяемый пользователем тип с помощью оператора Type.
Вы можете объявить несколько переменных в одном операторе. Чтобы указать тип данных, необходимо задать тип данных для каждой переменной.
В приведенном ниже операторе переменные intX , intY и intZ объявлены типом Integer.
В приведенном ниже операторе intX и intY объявлены как Variant и только intZ объявлен как тип Integer.
Нет необходимости указывать тип данных переменной в операторе объявления. Если вы не укажите тип данных, переменной будет присвоен тип Variant.
Сокращение для объявления переменных x и y типом Integer в приведенном выше операторе
Оператор Public
Оператор Public используется для объявления общих переменных на уровне модуля.
Общие переменные могут использоваться в любой процедуре проекта. Если общая переменная объявлена в стандартном модуле или модуле класса, она может использоваться в любых проектах, содержащих ссылку на проект, в котором объявлена данная общая переменная.
Оператор Private
Оператор Private используется для объявления частных переменных на уровне модуля.
Частные переменные могут использоваться только процедурами одного модуля.
На уровне модуля оператор Dim является эквивалентным оператору Private. Вы можете использовать оператор Private, чтобы упростить чтение и интерпретацию кода.
Оператор Static
Если для объявления переменной в процедуре используется оператор Static вместо оператора Dim, объявленная переменная сохраняет свое значение между вызовами в этой процедуре.
Оператор Option Explicit
В Visual Basic можно неявно объявить переменную, просто используя оператор присвоения значения. Все неявно объявленные переменные относятся к типу Variant. Для переменных типа Variant требуется больший объем памяти, чем для большинства других переменных. Приложение будет работать эффективнее, если переменные будут явно объявленными и им будет присвоен определенный тип данных. Явное объявление переменных снижает вероятность возникновения ошибок, вызванных конфликтом имен или опечатками.
Если вы не хотите, чтобы в Visual Basic были неявные объявления, то оператор Option Explicit должен стоять в модуле перед всеми процедурами. Этот оператор требует явного объявления всех переменных модуля. Если модуль содержит оператор Option Explicit, то при обнаружении необъявленной ранее переменной или опечатки в ее имени Visual Basic выдаст ошибку времени компиляции.
В программной среде Visual Basic имеется возможность задавать параметр, который будет автоматически включать оператор Option Explicit во все новые модули. Справочная информация по изменению параметров среды Visual Basic предоставлена в документации приложения. Обратите внимание, что данный параметр не меняет уже написанный код.
Статические и динамические массивы нужно объявлять в явном виде.
Объявление объектной переменной для автоматизации
При использовании приложения для управления объектами другого приложения необходимо указать ссылку на библиотеку типов этого другого приложения. Когда ссылка указана, можно объявлять объектные переменные в соответствии с наиболее подходящими для них типами. Например, если вы указываете ссылку на библиотеку типов Microsoft Excel при работе в Microsoft Word, то можете объявить переменную типа Worksheet внутри Word, чтобы она представляла объект Worksheet приложения Excel.
При использовании другого приложения для управления объектами Microsoft Access, как правило, можно объявлять объектные переменные согласно наиболее подходящим для них типам. Вы можете также использовать ключевое слово New для автоматического создания нового экземпляра объекта. Однако может возникнуть необходимость указать, что объект принадлежит Microsoft Access. Например, при объявлении объектной переменной, представляющей форму Access внутри Visual Basic, необходимо сделать различимыми объект Form приложения Access и объект Form приложения Visual Basic. Для этого следует включать имя библиотеки типов в объявление переменной, как показано в примере ниже:
Некоторые приложения не распознают отдельные объектные типы Access. Даже если в этих приложениях указана ссылка на библиотеку типов Access, все объектные переменные Access необходимо объявлять с типом Object. Также невозможно использовать ключевое слово New для создания нового экземпляра объекта.
В примере ниже показано, как объявлять переменную, представляющую экземпляр объекта Application Access в приложении, которое не распознает объектные типы Access. Затем приложение создает экземпляр объекта Application.
В документации приложения предоставлена информация о поддерживаемом им синтаксисе.
См. также
Поддержка и обратная связь
Есть вопросы или отзывы, касающиеся Office VBA или этой статьи? Руководство по другим способам получения поддержки и отправки отзывов см. в статье Поддержка Office VBA и обратная связь.
Читайте также: