Объявление переменных vba: Объявление переменной — Visual Basic

Тип данных 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. Т.е. если Вы не задаете каждой переменной свой тип хранимых данных явно

Dim MyVar1 As Integer, MyVar2 As Integer, MyVar3 As Integer

Это и есть объявление переменных. Т.е. сначала идет оператор области действия (Dim, Public,Static), сразу за ним имя переменной, затем оператор As и тип.
Но это не все. Некоторые типы переменным можно присваивать еще короче — даже без оператора As:

Dim MyVar1%, MyVar2%, MyVar3%

Всего шесть типов, которые можно объявить подобным методом:
! — Single
# — Double
$ — String
% — Integer
& — Long
@ — Currency
На что стоит обратить внимание, при объявлении переменных подобным образом: между именем переменной и знаком типа не должно быть пробелов.
Я лично в большинстве статей предпочитаю использовать первый метод, т.е. полное указание типа. Это читабельнее и понятнее. В каких-то проектах могу использовать краткое указание, в общих(разработка в команде) — полное. В своих кодах Вы вправе использовать удобный Вам метод — ошибки не будет.

Теперь разберемся с операторами области действия(Dim, Public и Static):

• Dim — данный оператор используется для объявления переменной, значение которой будет храниться только в той процедуре, внутри которой данная переменная объявлена. Во время запуска процедуры такая переменная инициализируется в памяти и использовать её значение можно внутри только этой процедуры, а по завершению процедуры переменная выгружается из памяти(обнуляется) и данные по ней теряются. Переменную, объявленную подобным образом еще называют локальной переменной. Однако с помощью данного оператора можно объявить переменную, которая будет доступна в любой процедуре модуля. Необходимо объявить переменную вне процедуры — в области объявлений(читать как первой строкой в модуле, после строк объявлений типа — Option Explicit). Тогда значение переменной будет доступно в любой процедуре лишь того модуля, в котором данная переменная была объявлена. Такие переменные называются переменными уровня модуля. Также для использования переменных во всех процедурах и функциях одного конкретного модуля можно использовать оператор Private. Но он в данном случае ничем не отличается от Dim, а пишется длиннее 🙂 Плюс, Private нельзя использовать внутри процедуры или функции(только в области объявлений), что еще больше сужает её применимость. По сути чаще этот оператор применяется к функциям и процедурам(об этом см.ниже)
• Static — данный оператор используется для объявления переменной, значение которой предполагается использовать внутри конкретной процедуры, но не теряя значения данной переменной по завершении процедуры. Переменные данного типа обычно используют в качестве накопительных счетчиков. Такая переменная инициализируется в памяти при первом запуске процедуры, в которой она объявлена. По завершении процедуры данные по переменной не выгружаются из памяти, но однако они не доступны в других процедурах. Как только Вы запустите процедуру с этой переменной еще раз — данные по такой переменной будут доступны в том виде, в котором были до завершения процедуры. Выгружается из памяти такая переменная только после закрытия проекта(книги с кодом).
• Public — данный оператор используется для объявления переменной, значение которой будет доступно в любой процедуре проекта(в обычных модулях, модулях класса, модулях форм, модулях листов и книг). Переменная, объявленная подобным образом, должна быть объявлена вне процедуры — в области объявлений. Такая переменная загружается в память во время загрузки проекта(при открытии книги) и хранит значение до выгрузки проекта(закрытия книги). Использовать её можно в любом модуле и любой процедуре проекта. Важно: объявлять подобным образом переменную необходимо строго в стандартном модуле. Такие переменные называются переменными уровня проекта. В простонародье такие переменные еще называют глобальными(возможно из-за того, что раньше подобные переменные объявлялись при помощи оператора Global, который в настоящее время устарел и не используется).
  Для большего понимания того, где и как объявлять переменные уровня проекта два небольших примера.
  Неправильное объявление

  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

  Если при этом вместо Public записать Dim, то эта переменная будет доступна из всех функций и процедур того модуля, в котором записана, но недоступна для функций и процедур других модулей.
  Переменные уровня проекта невозможно объявить внутри модулей классов(ClassModule, ЭтаКнига(ThisWorkbook), модулей листов, модулей форм(UserForm) — подробнее про типы модулей: Что такое модуль? Какие бывают модули?)

• Операторы области действия так же могут применяться и к процедурам. Для процедур доступен еще один оператор области действия — Private. Объявленная подобным образом процедура доступна только из того модуля, в котором записана и такая процедура не видна в диалоговом окне вызова макросов(Alt+F8)

'процедура записана в Module1 'эта процедура будет доступна для вызова исключительно из процедур в этом же модуле 'но не будет доступна при вызове из других модулей Private Sub PrivateMain() MsgBox "Процедура может быть вызвана только из модуля, в котором записана", vbInformation, "www. excel-vba.ru" End Sub 'другая процедура, записанная в этом же модуле Sub CallPrivate() Call PrivateMain End Sub

'эта процедура записана в другом модуле - Module2 'при попытке вызова этой процедурой получим ошибку ' Sub or Function not defined ' потому что процедура PrivateMain объявлена только для Module1 Sub CallPrivate_FromModule1() Call PrivateMain End Sub

При этом, если из Excel нажать сочетание клавиш Alt+F8, то в окне будут доступны только CallPrivate_FromModule1 и CallPrivate. Процедура PrivateMain будет недоступна.

 
Как правильно назвать переменную:

«Что самое сложное в работе программиста? — выдумывать имена переменным.» :-)А ведь придумать имя переменной тоже не так-то просто. Можно, конечно, давать им имена типа: a, d, f, x, y и т.д.(я сам иногда так делаю, но либо в простых кодах, либо для специального запутывания кода). Но стоит задуматься: а как Вы с ними будете управляться в большом коде? Код строк на 10 еще потерпит такие имена, а вот более крупные проекты — не советовал бы я в них оперировать такими переменными. Вы сами запутаетесь какая переменная как объявлена и какой тип данных может хранить и что за значение ей присвоено. Поэтому лучше всего давать переменным осмысленные имена и следовать соглашению об именовании переменных. Что за соглашение? Все очень просто: перед основным названием переменной ставится префикс, указывающий на тип данных, который мы предполагаем хранить в данной переменной. Про имеющиеся типы данных я уже рассказал выше. А ниже приведена примерная таблица соответствий префиксов типам данных:

Лично я немного для себя её переделал, т. к. некоторые обозначения мне кажутся скудными. Например 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 для всех букв(иначе говоря для всех переменных, которым не назначен тип данных явно через оператор As).

Ну и немаловажный момент это непосредственно осмысленное имя переменной. Имя переменной должно примерно отражать то, что в ней будет храниться. Например, Вы создаете отчет и Вам надо объявить две переменные: одна имя листа, другая имя книги. Можно было сделать так: str1, str2. Коротко, здорово. Но если подумать — и как можно понять, какая из этих переменных что хранит? Никак. Надо просматривать код и вспоминать, какой переменной какое значение было присвоено. Не совсем удобно, правда? А если бы Вы задали имена так: strBookName, strSheetName, то вроде как более понятно, что мы в них будем хранить. Это удобно не только вам самим при работе с кодом, но и другим людям, которые, возможно в будущем будут пользоваться Вашим кодом. Им будет удобнее читать код, если он будет оформлен грамотно, а переменные названы осмысленно. И не стоит экономить на длине имени — имя должно быть понятным. Без фанатизма, конечно :-). Хоть VBA и позволяет нам создавать переменные длиной до 254 символов, но читать такую переменную так же неудобно, как и с одним символом. Но здесь уже все зависит от Ваших предпочтений и фантазии.
Небольшое дополнение: лучше привыкать давать названия переменным на латинице(т.е. английский алфавит), т.к. для VBA английский язык «родной» и лучше использовать его.

 
Небольшой пример использования переменных в кодах:

Sub main()
'объявляем переменные с назначением конкретных типов
'As String - текст
'As Long   - целое число
Dim sAddress As String, sNewAddress As String, sShName As String
Dim lRow As Long
Dim rRange as Range 'назначили переменной тип ячейка/диапазон
 
'присвоили переменной rRange ссылку на текущую выделенную ячейку
Set rRange = Selection
'меняем выделение - выделяем ячейку D9
Range("D9").Select
'назначаем переменной адрес выделенных ячеек
sAddress = Selection.Address
'назначаем переменной lRow значение первой строки выделенной области
lRow = Selection.Row
'показываем сообщение
MsgBox "Адрес выделенной области: " & sAddress, vbInformation, "www.excel-vba. ru"
MsgBox "Номер первой строки: " & lRow, vbInformation, "www.excel-vba.ru"
'назначаем другой переменной значение адреса ячейки A1
sNewAddress = "A1"
'выделяем ячейку, заданную переменной sNewAddres
Range(sNewAddress).Select
MsgBox "Адрес выделенной области: " & sNewAddress, vbInformation, "www.excel-vba.ru"
'выделяем изначально выделенную ячейку, используя переменную rRange
rRange.Select
MsgBox "Адрес выделенной области: " & rRange.Address, vbInformation, "www.excel-vba.ru"
'задаем значение переменной
sShName = "excel-vba"
'переименовываем активный лист на имя, заданное переменной
ActiveSheet.Name = sShName
End Sub

Просмотреть пошагово выполнение данного кода поможет статья: Отлов ошибок и отладка кода 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
• сразу в момент объявления необходимо назначить константе значение: = «Имя моей программы»

Во всем остальном объявление и применение констант идентично объявлению переменных. Коротко приведу пару примеров.
Если константа объявлена внутри процедуры:

Sub TestConst()
    Const sMyConst As String = "Имя моей программы"
    MsgBox sMyConst 'показываем сообщение с именем программы
End Sub

то она не может быть использована в другой процедуре:

Sub TestConst()
    Const sMyConst As String = "Имя моей программы"
    MsgBox sMyConst 'показываем сообщение с именем программы
End Sub
Sub TestConst2()
    MsgBox sMyConst 'вызовет ошибку Variable not defined
End Sub

Чтобы использовать одну константу во всех процедурах модуля(того, в котором она объявлена), необходимо объявить её в области объявлений:

Const sMyConst As String = "Имя моей программы"
Sub TestConst()
    MsgBox sMyConst 'показываем сообщение с именем программы
End Sub
Sub TestConst2()
    MsgBox sMyConst 'уже не вызовет ошибку Variable not defined
End Sub

Чтобы использовать одну константу во всех процедурах проекта(книги), необходимо объявить её как Public:

Public Const sMyConst As String = "Имя моей программы"
Sub TestConst()
    MsgBox sMyConst 'показываем сообщение с именем программы
End Sub
Sub TestConst2()
    MsgBox sMyConst 'не вызовет ошибку Variable not defined, даже если процедура в другом модуле
End Sub

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

Также см.:
Variable not defined или что такое Option Explicit и зачем оно нужно?
Что такое модуль? Какие бывают модули?
Что такое макрос и где его искать?
Отлов ошибок и отладка кода VBA

Статья помогла? Поделись ссылкой с друзьями!

Поиск по меткам

Accessapple watchMultexPower Query и Power BIVBA управление кодамиБесплатные надстройкиДата и времяЗапискиИПНадстройкиПечатьПолитика КонфиденциальностиПочтаПрограммыРабота с приложениямиРазработка приложенийРосстатТренинги и вебинарыФинансовыеФорматированиеФункции Excelакции MulTExссылкистатистика

Переменные и константы в VBA

Автор Антон Андронов На чтение 9 мин Опубликовано 03.12.2015

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

Например, константа Pi хранит значение 3,14159265… Число «Пи» не будет изменяться в ходе выполнения программы, но все же хранить такое значение удобнее как константу.

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

Содержание

1. Типы данных
2. Объявление переменных и констант
3. Option Explicit
4. Область действия переменных и констант

Типы данных

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

Тип данных	Размер	Описание	Диапазон значений
Byte	1 байт	Положительные целые числа; часто используется для двоичных данных	от 0 до 255
Boolean	2 байта	Может принимать значения либо True, либо False	True или False
Integer	2 байта	Целые числа (нет дробной части)	от -32 768 до +32 767
Long	4 байта	Большие целые числа (нет дробной части)	от -2 147 483 648 до +2 147 483 647
Single	4 байта	Число с плавающей точкой одинарной точности	от -3. 4e38 до +3.4e38
Double	8 байт	Число с плавающей точкой двойной точности	от -1.8e308 до +1.8e308
Currency	8 байт	Число с плавающей точкой, с фиксированным количеством десятичных разрядов	от -922 337 203 685 477.5808 до +922 337 203 685 477.5807
Date	8 байт	Дата и время – данные типа Date представлены числом с плавающей точкой. Целая часть этого числа выражает дату, а дробная часть – время	от 1 Января 100 до 31 Декабря 9999
Object	4 байта	Ссылка на объект	Любая ссылка на объект
String	изменяется	Набор символов. Тип String может иметь фиксированную или изменяющуюся длину. Чаще используется с изменяющейся длиной	Фиксированной длины — приблизительно до 65 500 символов. Переменной длины — приблизительно до 2 миллиардов символов
Variant	изменяется	Может содержать дату, число с плавающей точкой или строку символов. Этот тип используют в тех случаях, когда заранее не известно, какой именно тип данных будет введён	Число – Double, строка – String

Очевидно, что пользуясь приведённой выше таблицей и правильно выбирая тип данных, можно использовать память более экономно (например, выбрать тип данных Integer вместо Long или Single вместо Double). Однако, используя более компактные типы данных, нужно внимательно следить за тем, чтобы в коде не было попыток уместить в них не соразмерно большие значения.

Объявление переменных и констант

Примечание переводчика: Говоря о переменных в VBA, стоит упомянуть ещё один очень важный момент. Если мы объявляем переменную, но не присваиваем ей какое-либо значение, то она инициализируется значением по умолчанию:
• текстовые строки — инициализируются пустыми строками;
• числа — значением 0;
• переменные типа Boolean — False;
• даты — 30 декабря 1899.

Прежде чем использовать переменную или константу, её нужно объявить. Для этого в макрос добавляют вот такую простую строку кода:

Dim Имя_Переменной As Тип_Данных

В показанной выше строке кода Имя_Переменной – это имя переменной, которая будет использована в коде, а Тип_Данных – это один из типов данных из таблицы, приведённой чуть ранее в этой статье. Например:

Dim sVAT_Rate As Single
Dim i As Integer

Аналогично объявляются константы, но при объявлении констант обязательно сразу указывается их значение. Например, вот так:

Const iMaxCount = 5000
Const iMaxScore = 100

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

Таким образом, программист в любой момент сможет использовать новую переменную (даже если она не была объявлена), и Excel будет рассматривать её как переменную типа Variant. Однако, есть несколько причин, почему так поступать не следует:

1. Использование памяти и скорость вычислений. Если не объявлять переменную с указанием типа данных, то по умолчанию для неё будет установлен тип Variant. Этот тип данных использует больше памяти, чем другие типы данных.Казалось бы, несколько лишних байт на каждую переменную – не так уж много, но на практике в создаваемых программах могут быть тысячи переменных (особенно при работе с массивами). Поэтому излишняя память, используемая переменными типа Variant, по сравнению с переменными типа Integer или Single, может сложится в значительную сумму.К тому же, операции с переменными типа Variant выполняются гораздо медленнее, чем с переменными других типов, соответственно лишняя тысяча переменных типа Variant может значительно замедлить вычисления.
2. Профилактика опечаток в именах переменных. Если все переменные объявляются, то можно использовать оператор VBA — Option Explicit (о нём расскажем далее), чтобы выявить все не объявленные переменные.Таким образом исключается появление в программе ошибки в результате не верно записанного имени переменной. Например, используя в коде переменную с именем sVAT_Rate, можно допустить опечатку и, присваивая значение этой переменной, записать: «VATRate = 0,175». Ожидается, что с этого момента, переменная sVAT_Rate должна содержать значение 0,175 – но, конечно же, этого не происходит. Если же включен режим обязательного объявления всех используемых переменных, то компилятор VBA сразу же укажет на ошибку, так как не найдёт переменную VATRate среди объявленных.
3. Выделение значений, не соответствующих объявленному типу переменной. Если объявить переменную определённого типа и попытаться присвоить ей данные другого типа, то появится ошибка, не исправив которую, можно получить сбой в работе программы. На первый взгляд, это может показаться хорошей причиной, чтобы не объявлять переменные, но на самом деле, чем раньше выяснится, что одна из переменных получила не те данные, которые должна была получить – тем лучше! Иначе, если программа продолжит работу, результаты могут оказаться неверными и неожиданными, а найти причину ошибок будет гораздо сложнее.Возможно также, что макрос будет «успешно» выполнен. В результате ошибка останется незамеченной и работа продолжится с неверными данными!

В связи с этим, неверный тип данных желательно обнаруживать и как можно раньше исправлять такие ошибки в коде. По этим причинам при написании макроса VBA рекомендуется объявлять все переменные.

Option Explicit

Оператор Option Explicit заставляет объявлять все переменные, которые будут использованы в коде VBA, и при компиляции выделяет все не объявленные переменные как ошибки (прежде чем будет запущено выполнение кода). Применить этот оператор не сложно – просто запишите в самом верху файла VBA такую строку:

Option Explicit

Если хотите всегда вставлять Option Explicit в начало каждого нового созданного модуля VBA, то это можно делать автоматически. Для этого необходимо включить параметр Require Variable Declaration в настройках редактора VBA.

Это делается так:

• В меню редактора Visual Basic нажмите Tools > Options
• В появившемся диалоговом окне откройте вкладку Editor
• Отметьте галочкой параметр Require Variable Declaration и нажмите ОК

При включенном параметре строка Option Explicit будет автоматически вставляться в начало каждого нового созданного модуля.

Область действия переменных и констант

Каждая объявленная переменная или константа имеет свою ограниченную область действия, то есть ограниченную часть программы, в которой эта переменная существует. Область действия зависит от того, где было сделано объявление переменной или константы. Возьмём, к примеру, переменную sVAT_Rate, которая используется в функции Total_Cost. В следующей таблице рассмотрены два варианта области действия переменной sVAT_Rate, объявленной в двух различных позициях в модуле:

Option Explicit

Dim sVAT_Rate As Single

Function Total_Cost() As Double


...


End Function

Option Explicit

Function Total_Cost() As Double

Dim sVAT_Rate As Single


. ..


End Function

В показанном выше примере переменная объявлена на уровне модуля при помощи ключевого слова Dim. Однако, бывает необходимо, чтобы объявленными переменными можно было пользоваться в других модулях. В таких случаях для объявления переменной вместо ключевого слова Dim нужно использовать ключевое слово Public.

Кстати, для того, чтобы объявить переменную на уровне модуля, вместо ключевого слова Dim можно использовать ключевое слово Private, которое укажет на то, что данная переменная предназначена для использования только в текущем модуле.

Для объявления констант также можно использовать ключевые слова Public и Private, но не вместо ключевого слова Const, а вместе с ним.

В следующих примерах показано использование ключевых слов Public и Private в применении к переменным и к константам.

Option Explicit Public sVAT_Rate As Single Public Const iMax_Count = 5000 ...	В этом примере ключевое слово Public использовано для объявления переменной sVAT_Rate и константы iMax_Count. Областью действия объявленных таким образом элементов будет весь текущий проект. Это значит, что sVAT_Rate и iMax_Count будут доступны в любом модуле проекта.
Option Explicit Private sVAT_Rate As Single Private Const iMax_Count = 5000 ...	В этом примере для объявления переменной sVAT_Rate и константы iMax_Count использовано ключевое слово Private. Областью действия этих элементов является текущий модуль. Это значит, что sVAT_Rate и iMax_Count будут доступны во всех процедурах текущего модуля, но не будут доступны для процедур, находящихся в других модулях.

Урок подготовлен для Вас командой сайта office-guru.ru
Источник: http://www.excelfunctions.net/VBA-Variables-And-Constants.html
Перевел: Антон Андронов
Правила перепечатки
Еще больше уроков по Microsoft Excel

Оцените качество статьи. Нам важно ваше мнение:

Объявление переменной VBA — voxt.

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

Объявление переменной в VBA

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

Что такое переменные в VBA?

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

Какая польза от переменной?

Когда вы создаете программу или код, они состоят из некоторых инструкций, которые передают в систему информацию о том, что делать с данными. Данные состоят из двух типов значений, фиксированных и переменных. Фиксированные значения также называются постоянными. Переменные определяются определенными типами данных, т. е. целое число, байт, строка и т. д. Это помогает нам определить характер вводимых данных, т. е. текст, число, логическое значение и т. д.

Как объявить переменную?

Чтобы объявить переменную в коде, вы должны присвоить ей имя. Вы можете присвоить любое имя переменной. Однако рекомендуется выбирать имя переменной, которое относится к данным, чтобы другие пользователи также могли легко его понять. Например, если вам нужно передать целочисленные данные в коде, то переменные имени, такие как i_count или out. Если вам нужно передать строковое значение, вы можете назвать эту переменную, например, strName

Переменные могут быть объявлены в любом месте код VBAКод VBAКод VBA относится к набору инструкций, написанных пользователем на языке программирования приложений Visual Basic в редакторе Visual Basic (VBE) для выполнения определенной задачи. читать далее. Тем не менее, кодировщику рекомендуется объявлять их в начале кода, чтобы каждый пользователь мог легко понять код. Переменная должна быть объявлена ​​с помощью Dim.

Вы можете использовать это изображение на своем веб-сайте, в шаблонах и т. д. Пожалуйста, предоставьте нам ссылку на авторствоКак предоставить атрибуцию?Ссылка на статью должна быть гиперссылкой
Например:
Источник: Объявление переменных VBA (wallstreetmojo.com)

Примеры объявления переменных VBA

Вот несколько примеров, чтобы вы поняли Тип данных VBAТип данных VBAТип данных — это основной признак любой переменной. Он представляет, какой тип и диапазон значений мы можем хранить в переменной. Типы данных встроены в VBA, и пользователям или разработчикам необходимо знать, какое значение может храниться в каком типе данных.читать далее. Вы можете попробовать это на своем компьютере.

Добавьте модуль в Редактор VBAРедактор VBAРедактор Visual Basic для приложений — это интерфейс сценариев. Эти сценарии в первую очередь отвечают за создание и выполнение макросов в программном обеспечении Microsoft.читать далее. Скопируйте и вставьте приведенные ниже коды один за другим, чтобы увидеть результат.

Вы можете скачать этот шаблон Excel для объявления переменных VBA здесь — Шаблон Excel объявления переменной VBA

Пример объявления переменной VBA № 1 — целое число

Целое число VBAЦелое число VBAВ VBA целое число — это тип данных, который может быть присвоен любой переменной и использоваться для хранения целочисленных значений. В VBA скобка для максимального числа целочисленных переменных, которые можно сохранить, аналогична скобке в других языках. Используя оператор DIM, любую переменную можно определить как целочисленную переменную.читать далее Тип данных используется, когда вам нужно хранить целые числа. Целое число может хранить значение от 32 768 до 32 767. Если вам нужно передать значение за пределы этого, вам нужно использовать Длинный тип данных в VBAДлинный тип данных в VBALong — это тип данных в VBA, который используется для хранения числовых значений. Мы знаем, что целые числа также хранят числовые значения, но тип Long отличается от целых тем, что диапазон для хранения данных намного больше в случае типа данных long.читать далее.

Код:

Sub VBA_Code1()
 Dim Score As Integer
 Score = 101
 MsgBox "Sachin Scored " & Score
End Sub

Когда вы запустите приведенный выше код, результат покажет Sachin Scored 101. См. ниже.

Пример объявления переменной VBA № 2 — строка

То Строковый тип данных VBAСтроковый тип данных VBAVBA SubString — важная функция, используемая для разделения данных путем разделения строки VBA на разные подстроки. В VBA доступны три типа функций подстроки, т. е. функции слева-направо, посередине и функции разделения.читать далее может хранить данные в виде текста.

Код:

Sub VBA_Code_String()
 Dim strName As String
 strName = "Ram"
 Range("A1:A10") = "Ram"
End Sub

Когда вы запустите приведенный выше код, он введет Ram в каждую ячейку между диапазоном A1: A10.

Пример объявления переменной VBA № 3 — Дата

То тип данных даты в VBAТип данных даты в VBAVBA Date — это функция даты и времени. Он возвращает только текущую дату в соответствии с системной датой, которую вы используете, и не имеет никаких аргументов. Эта функция возвращает текущую системную дату.читать далее может хранить данные, такие как дата. Он будет в формате ММ/ДД/ГГГГ.

Код:

Sub VBA_Code_Date()
 Dim DOB As Date
 
 DOB = "04/04/1990"
 MsgBox "I was born on " & DOB
End Sub

Когда вы запустите приведенный выше код, это покажет результат, как показано ниже.

Пример объявления переменной VBA № 4 — логическое значение

Логический тип данных в VBAЛогический тип данных в VBABoolean — это встроенный тип данных в VBA, используемый для логических ссылок или логических переменных. Значение, которое содержит этот тип данных, равно TRUE или FALSE и используется для логического сравнения. Объявление этого типа данных аналогично всем другим типам данных. читать далее имеет только два значения True или False.

Код:

Sub VBA_Code_Boolean()
 Dim bgender As Boolean
 bgender = False
 If bgender = True Then
 Range("A1") = "Male"
 Else
 Range("A1") = "Female"
 End If
End Sub

Когда вы запускаете код, результат в ячейке A1 будет женский.

Пример объявления переменной VBA № 5 — длинный

Тип данных Long также используется для хранения чисел. Они могут хранить числа от -2 147 483 648 до 2 147 483 647. Здесь у вас должен возникнуть вопрос, если Integer и Long могут хранить числа, то почему мы используем Integer?

Вот ответ: Integer занимает два байта. Однако для Long требуется 8 байт пространства. Поэтому, когда вы знаете, что это число может быть сохранено как целое число, вы не должны использовать long, иначе время работы вашей программы увеличится.

Предположим, вам нужно показать расстояние между Северным полюсом и Южным полюсом в метрах, и вы знаете, что расстояние в метрах находится за пределами диапазона от -32 768 до 32 767. Таким образом, вы будете использовать тип данных Long.

Код:

Sub VBA_Code_long()
Dim distance As Long
distance = 13832000
MsgBox "Distance between the North Pole and 
the South Pole is " & distance & " Meter"
End Sub

Результатом будет «Расстояние между Северным полюсом и Южным полюсом 13832000 метров».

Если вы используете целое число в качестве типа данных в приведенном выше коде, это приведет к ошибке. Можешь попробовать.

Очки, чтобы помнить

Вам нужно помнить некоторые моменты при объявлении переменных.

• Имя переменной не должно быть длиннее 255 символов.
• Переменные не чувствительны к регистру.
• Переменная не должна начинаться с цифры. Вы можете использовать цифру или подчеркивание в середине имени переменной.
• Объявление переменной VBA не может быть названо ключевым словом Excel, таким как Sheet, Range и т. д.
• Объявление переменной VBA не содержало специальных символов.

УЗНАТЬ БОЛЬШЕ >>

Post Views: 278

Похожие записи

Работа с переменными в Excel используя макрос

Алан Перлис

Постоянная одного человека — переменная другого

Эта статья содержит полное руководство по работе с переменными и использованию VBA Dim.

Первый раздел содержит краткое руководство по использованию оператора Dim, включая примеры и формат оператора Dim.

Остальная часть поста содержит наиболее полное руководство, которое вы найдете в VBA Dim Statement.

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

Содержание

1. Краткое руководство по использованию VBA Dim Statement
2. Полезные ссылки 
3. Что такое VBA Dim Statement?
4. Формат VBA Dim Statement
5. Как использовать Dim с несколькими переменными
6. Где я должен поместить Dim Statement?
7. Использование Dim в циклах
8. Могу ли я использовать Dim для присвоения значения?
9. Dim действительно требуется?
10. Использование Dim с Basic Variables
11. Использование Dim с Variants
12. Использование Dim с Objects
13. Использование Dim с Arrays
14. Устранение неполадок ошибок  Dim
15. Локальные и глобальные переменные
16. Заключение

Описание	Формат	Пример
Базовая переменная	Dim [имя переменной]  As [Тип]	Dim count As Long Dim amount  As Currency Dim name As String Dim visible  As Boolean
Фиксированная строка	Dim [имя переменной]  As String *[размер]	Dim s As String * 4 Dim t As String * 10
Вариант	Dim [имя переменной]  As Variant Dim [имя переменной]	Dim var As Variant Dim var
Объект использует Dim и New	Dim [имя переменной]  As New [тип объекта]	Dim coll As New  Collection Dim coll As New  Class1
Объект использует Dim и New	Dim [имя переменной]  As [тип объекта] Set [имя переменной] = New [тип объекта]	Dim coll As Collection Set coll = New  Collection Dim coll As Class1 Set coll = New Class1
Статический массив	Dim [имя переменной] ([первый]  To [последний] )  As[Тип]	Dim arr(1 To 6)  As Long
Динамический массив	Dim [имя переменной]()  As [Тип] ReDim [имя переменной] ([первый]  To [последний])	Dim arr() As Long ReDim arr(1 To 6)
Внешняя библиотека (Раннее связывание) *	Dim [имя переменной]  As New [пункт]	Dim dict  As New Dictionary
Внешняя библиотека (Раннее связывание с использованием Set) *	Dim [имя переменной]  As [пункт] Set [имя переменной] =  New [пункт]	Dim dict As Dictionary Set dict =  New Dictonary
Внешняя библиотека (Позднее связывание)	Dim [имя переменной]  As Object Set [имя переменной] = CreateObject («[библиотека]»)	Dim dict As Object Set dict = CreateObject(«Scripting. Dictionary»)

* Примечание. Для раннего связывания необходимо добавить справочный файл с помощью меню «Инструменты» -> «Ссылки». Смотрите здесь, как добавить ссылку на Dictonary.

• Объявление параметров в подпрограмме или функции
• Использование объектов в VBA
• Массивы VBA
• Коллекции VBA
• Словарь VBA
• VBA Workbook
• VBA Worksheet

Ключевое слово Dim — это сокращение от Dimension. Он используется для объявления переменных в VBA.

Объявление означает, что мы говорим VBA о переменной, которую будем использовать позже.

Существует четыре типа Dim Statement. Все они очень похожи по синтаксису.

Вот они:

1. Basic variable
2. Variant
3. Object
4. Array

Ниже приводится краткое описание каждого типа

1. Basic variable — этот тип переменной содержит одно значение. Это такие типы, как Long, String, Date, Double, Currency.
2. Variant — VBA решает во время выполнения, какой тип будет использоваться. Вы должны избегать вариантов, где это возможно, но в некоторых случаях требуется их использование.
3. Object — это переменная, которая может иметь несколько методов (то есть подпрограмм / функций) и несколько свойств (то есть значений). Есть 3 вида:
   Объекты Excel, такие как объекты Workbook, Worksheet и Range.
   Пользовательские объекты, созданные с использованием модулей классов.
   Внешние библиотеки, такие как Словарь.
4. Array — это группа переменных или объектов.

В следующем разделе мы рассмотрим формат оператора VBA Dim с некоторыми примерами каждого из них.

В последующих разделах мы рассмотрим каждый тип более подробно.

Формат выражения Dim показан ниже.

' 1. BASIC VARIABLE
' Объявление основной переменной
Dim [Имя переменной] As [тип]
' Объявление фиксированной строки
Dim [Имя переменной] As String * [размер]
' 2.  VARIANT
Dim [Имя переменной] As Variant
Dim [Имя переменной]
' 3. OBJECT
' Объявление объекта
Dim [Имя переменной] As [тип]
' Объявление и создание объекта
Dim [Имя переменной] As New [тип]
' Объявление объекта с использованием позднего связывания
Dim [Имя переменной] As Object
' 4. ARRAY
' Объявление статического массива
Dim [Имя переменной](first To last) As [тип]
' Объявление динамического массива
Dim [Имя переменной]() As [тип]
Ниже приведены примеры использования различных форматов.
Sub Primeri()
    ' 1. BASIC VARIABLE
    ' Объявление основной переменной
    Dim name As String
    Dim count As Long
    Dim amount As Currency
    Dim eventdate As Date
    
    ' Объявление фиксированной строки
    Dim userid As String * 8
    
    ' 2. VARIANT
    Dim var As Variant
    Dim var
    
    ' 3. OBJECT
    ' Объявление объекта
    Dim sh As Worksheet
    Dim wk As Workbook
    Dim rg As Range
    
    ' Объявление и создание объекта
    Dim coll1 As New Collection
    Dim o1 As New Class1
    
    ' Объявление объекта - создайте объект ниже, используя Set
    Dim coll2 As Collection
    Dim o2 As Class1
    
    Set coll2 = New Collection
    Set o2 = New Class1
    
    ' 	Объявление и присвоение с использованием позднего связывания
    Dim dict As Object
    Set dict = CreateObject("Scripting. Dictionary")
    
    ' 4. ARRAY
    ' Объявление статического массива
    Dim arrScores(1 To 5) As Long
    Dim arrCountries(0 To 9) As String
    
    ' Объявление динамического массива - установите размер ниже, используя ReDim
    Dim arrMarks() As Long
    Dim arrNames() As String
    
    ReDim arrMarks(1 To 10) As Long
    ReDim arrNames(1 To 10) As String
End Sub

Мы рассмотрим эти различные типы операторов Dim в следующих разделах.

Мы можем объявить несколько переменных в одном выражении Dim.

Dim name As String, age As Long, count As Long

Если мы опускаем тип, то VBA автоматически устанавливает тип как Variant. Мы увидим больше о Variant позже.

' Сумма является вариантом
Dim amount As Variant
' Сумма является вариантом
Dim amount
' Адрес это вариант - имя это строка
Dim name As String, address
' имя - это вариант, адрес – строка
Dim name, address As String

Когда вы объявляете несколько переменных, вы должны указать тип каждой отдельно.

Dim wk As Workbook, marks As Count, name As String

Вы можете поместить столько переменных, сколько захотите, в одном выражении Dim, но для удобства чтения рекомендуется оставить его равным 3 или 4.

Оператор Dim может быть помещен в любое место кода. Тем не менее, он должен предшествовать любой строке, где используется переменная.

Если переменная используется перед оператором Dim, вы получите ошибку «переменная не определена»

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

Sub DimVverh()
    ' Размещение всех Dim statements наверху
    Dim count As Long, name As String, i As Long
    Dim wk As Workbook, sh As Worksheet, rg As Range
    
    Set wk = Workbooks.Open("C:\Документы\Отчет.xlsx")
    Set sh = wk.Worksheets(1)
    Set rg = sh.Range("A1:A10")
    
    For i = 1 To rg.Rows.count
        count = rg. Value
        Debug.Print count
    Next i
  
End Sub

ИЛИ вы можете объявить переменные непосредственно перед их использованием:

Sub DimIsp()
    Dim wk As Workbook
    Set wk = Workbooks.Open("C:\Документы\Отчет.xlsx")
    
    Dim sh As Worksheet
    Set sh = wk.Worksheets(1)
    
    Dim rg As Range
    Set rg = sh.Range("A1:A10")
    
    Dim i As Long, count As Long, name As String
    For i = 1 To rg.Rows.count
        count = rg.Value
        name = rg.Offset(0, 1).Value
        Debug.Print name, count
    Next i
  
End Sub

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

Помещение оператора Dim в цикл не влияет на переменную.

Когда VBA запускает Sub (или Function), первым делом он создает все переменные, которые были объявлены в выражениях Dim.

Следующие 2 фрагмента кода практически одинаковы. Во-первых, переменная Count объявляется перед циклом. Во втором он объявлен в цикле.

Sub CountPeredCiklom()
    Dim count As Long
    Dim i As Long
    For i = 1 To 3
        count = count + 1
    Next i
    
    ' значение счета будет 3
    Debug.Print count
End Sub

Sub CountPosleCikla()
    Dim i As Long
    For i = 1 To 3
        Dim count As Long
        count = count + 1
    Next i
    
    ' значение счета будет 3
    Debug.Print count
End Sub

Код будет вести себя точно так же, потому что VBA создаст переменные при входе в подпрограмму.

В таких языках, как C ++, C # и Java, мы можем объявлять и назначать переменные в одной строке:

' C++
int i = 6
String name = "Иван"

Мы не можем сделать это в VBA. Мы можем использовать оператор двоеточия для размещения объявлений и назначения строк в одной строке.

Dim count As Long: count = 6

Мы не объявляем и не присваиваем в одной строке VBA. Что мы делаем, это помещаем эти две строки (ниже) в одну строку в редакторе. Что касается VBA, это две отдельные строки, как здесь:

Dim count As Long
count = 6

Здесь мы помещаем 3 строки кода в одну строку редактора, используя двоеточие:

count = 1: count = 2: Set wk = ThisWorkbook

Нет никаких преимуществ или недостатков в назначении и объявлении в одной строке редактора. Все сводится к личным предпочтениям.

Ответ в том, что это не обязательно. VBA не требует от вас использовать Dim Statement.

Однако не использовать оператор Dim — плохая практика и может привести к множеству проблем.

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

Это может привести к таким проблемам, как

1. Все переменные являются вариантами (проблемы с этим см. В разделе «Варианты»).
2. Некоторые переменные ошибки останутся незамеченными.

Из-за этих проблем рекомендуется сделать использование Dim обязательным в нашем коде. Мы делаем это с помощью оператора Option Explicit.

Option Explicit

 Мы можем сделать Dim обязательным в модуле, набрав «Option Explicit» в верхней части модуля.

Мы можем сделать это автоматически в каждом новом модуле, выбрав Tools-> Options из меню и отметив флажок «Требовать декларацию переменной». Затем, когда вы вставите новый модуль, «Option Explicit» будет автоматически добавлен в начало.

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

Ошибки Переменной

В приведенном ниже коде мы используем переменную Total без использования оператора Dim.

Sub BezDim()
    Total = 6
    
    Total = Total + 1
    
    Debug.Print Total
End Sub

Если мы случайно написали Total неправильно, VBA сочтет это новой переменной.

В приведенном ниже коде мы неправильно написали переменную Total как Totall.

Sub BezDimOshibki()
    Total = 6
    
    ' Первый Total - это ошибка
    Totall = Total + 1
    
    ' напечатает 6 вместо 7
    Debug.Print Total
End Sub

VBA не обнаружит ошибок в коде, и будет напечатано неверное значение.

Давайте добавим Option Explicit и попробуйте приведенный выше код снова

Option Explicit 
Sub BezDimOshibki()
    Total = 6
    
    ' Первый Total - это ошибка
    Totall = Total + 1
    
    ' Напечатает 6 вместо 7
    Debug.Print Total
End Sub

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

Когда мы добавим оператор Dim для Total и запустим код, мы получим ошибку, сообщающую, что опечатка Totall не была определена.

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

Ошибка в ключевом слове

Вот второй пример, который более тонкий.

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

Однако, когда код запускается, ничего не происходит.

Sub ZadatCvet()
    Sheet1.Range("A1").Font.Color = rgblue
End Sub

Ошибка здесь в том, что rgblue должен быть rgbBlue. Если вы добавите Option Explicit в модуль, появится ошибка «переменная не определена». Это значительно облегчает решение проблемы.

Эти два примера очень просты. Если у вас много кода, то подобные ошибки могут стать кошмаром для отслеживания.

Использование Dim с Basic Variables

VBA имеет те же основные типы переменных, которые используются в электронной таблице Excel.

Вы можете увидеть список всех типов переменных VBA здесь.

Тем не менее, большую часть времени вы будете использовать следующие:

Тип	Хранение	Диапазон	Описание
Boolean	2 байта	ИСТИНА или ЛОЖЬ	Эта переменная может быть ИСТИНА или ЛОЖЬ.
Long	4 байта	от -2,147,483,648 до 2,147,483,647	Long — это сокращение от Long Integer. Используйте это вместо типа Integer *
Currency	8 байт	от -1,79769313486231E308 до -4,94065645841247E-324 для отрицательных значений; от 4.94065645841247E-324 до 1.79769313486232E308 для положительных значений	Аналогично Double, но имеет только 4 знака после запятой
Double	8 байт	от -922,337,203,685,477.5808 до 922,337,203,685,477.5807
Date	8 байт	С 1 января 100 по 31 декабря 9999
String	меняется	От 0 до примерно 2 миллиардов	Содержит текст

* Первоначально мы использовали бы тип Long вместо Integer, потому что Integer был 16-разрядным, и поэтому диапазон был от -32 768 до 32 767, что довольно мало для многих случаев использования целых чисел.

Однако в 32-битной (или выше) системе целое число автоматически преобразуется в длинное. Поскольку Windows была 32-битной начиная с Windows 95 \ NT, нет смысла использовать Integer.

В двух словах, всегда используйте Long для целочисленного типа в VBA.

Фиксированный тип строки

В VBA есть один необычный тип базовой переменной, с которым вы, возможно, не знакомы.

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

Sub TipStroki()
    Dim s As String
    
    ' s is "Иван Петров"
    s = "John Smith"
    
    ' s is "Игорь"
    s = "Tom"
End Sub

Фиксированная строка никогда не изменяется. Эта строка всегда будет иметь одинаковый размер независимо от того, что вы ей назначаете

вот несколько примеров:

Sub FiksStroka()
    
    Dim s As String * 4
    
    ' s is "Иван"
    s = "Иван Перов"
    
    ' s = "Игорь "
    s = "Игорь"
End Sub

Использование Dim с Variants

Когда мы объявляем переменную как вариант, VBA решает во время выполнения, какой тип переменной должен быть.

Мы объявляем варианты следующим образом

' Оба варианта
Dim count
Dim count As Variant
Это звучит как отличная идея в теории. Больше не нужно беспокоиться о типе переменной
Sub IspVariants()
    
    Dim count As Variant
        
    count = 7
    
    count = "Иван"
    
    count = #12/1/2018#
End Sub

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

1. VBA не будет замечать неправильных ошибок типа (т. Е. Несоответствие данных).
2. Вы не можете получить доступ к Intellisense.
3. VBA угадывает лучший тип, и это может быть не то, что вы хотите.

Тип ошибки

Ошибки твои друзья!

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

Ошибка несоответствия типов предупреждает вас, когда используются неверные данные.

Например. Представьте, что у нас есть лист оценок учеников. Если кто-то случайно (или намеренно) заменит метку на текст, данные будут недействительными.

Если мы используем вариант для хранения меток, то ошибки не возникнет

Sub MarksVariant()
    
    Dim marks As Variant
    
    Dim i As Long
    For i = 1 To 10
        
        ' Прочитайте отметку
        mark = Sheet1.Range("A" & i).Value
        
    Next
End Sub

Это не хорошо, потому что в ваших данных есть ошибка, а вы не знаете об этом.

Если вы зададите переменную Long, VBA сообщит вам об ошибке «Несоответствие типов», если значения являются текстовыми.

Sub MarksLong()
    
    Dim mark As Long
    
    Dim i As Long
    For i = 1 To 10
        
        ' Прочитайте отметку
        mark = Sheet1.Range("A" & i).Value
        
    Next
End Sub

Доступ к Intellisense

Intellisense — удивительная особенность VBA. Он дает вам доступные параметры в зависимости от типа, который вы создали.

Представьте, что вы объявляете переменную листа, используя Dim

Dim wk As Workbook

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

Вы можете увидеть Intellisense на скриншоте ниже

Если вы используете Variant как тип, то Intellisense будет недоступен

Dim wk As Variant

Это потому, что VBA не будет знать тип переменной до времени выполнения.

Если вы не знаете, что такое Objects, вы можете прочитать мою статью об VBA Objects здесь.

Есть 3 типа объектов:

1. Объекты Excel
2. Объекты модуля класса
3. Внешние объекты библиотеки

Примечание. Объект VBA Collection используется аналогично тому, как мы используем объект Class Module. Мы используем новое, чтобы создать его.

Давайте посмотрим на каждый из них по очереди.

Объекты Excel

Объекты Excel, такие как Рабочая книга, Рабочий лист, Диапазон и т. Д., Не используют Новый, поскольку они автоматически создаются Excel. Смотрите, «когда New не требуется».

При создании или открытии книги Excel автоматически создает связанный объект.

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

Sub OtkrWorkbook()
    
    Dim wk As Workbook
    Set wk = Workbooks.Open("C:\Документы\Отчет.xlsx")
End Sub

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

Sub DobavSheet()
    
    Dim sh As Worksheet
    Set sh = ThisWorkbook.Worksheets.Add
End Sub

Нам не нужно использовать ключевое слово New для этих объектов Excel.

Мы просто присваиваем переменную функции, которая либо создает новый объект, либо дает нам доступ к существующему.

Вот несколько примеров назначения переменных Workbook, Worksheet и range

Sub DimWorkbook()
    
    Dim wk As Workbook
    
    ' назначить wk новой книге
    Set wk = Workbooks.Add
    
    ' назначить wk первой открытой книге
    Set wk = Workbooks(1)
    
    ' назначить wk рабочей книге Отчет. xlsx
    Set wk = Workbooks("Отчет.xlsx")
    
    ' назначить wk активной книге
    Set wk = ActiveWorkbook
    
End Sub

Sub DimWorksheet()
    
    Dim sh As Worksheet
    
    ' Назначить sh на новый лист
    Set sh = ThisWorkbook.Worksheets.Add
    
    ' Назначьте sh на крайний левый лист
    Set sh = ThisWorkbook.Worksheets(1)
    
    ' Назначьте sh на лист под названием «Клиенты»
    Set sh = ThisWorkbook.Worksheets("Клиенты")
    
    ' Присвойте sh активному листу
    Set sh = ActiveSheet
End Sub

Sub DimRange()
    ' Получить рабочий лист клиента
    Dim sh As Worksheet
    Set sh = ThisWorkbook.Worksheets("Клиенты")
    
    ' Объявите переменную диапазона
    Dim rg As Range
    
    ' Присвойте rg диапазону A1
    Set rg = sh.Range("A1")
    
    ' Назначьте rg в диапазоне от B4 до F10
    Set rg = sh.Range("B4:F10")
    
    ' Присвойте rg диапазону E1
    Set rg = sh.Cells(1, 5)
    
End Sub

Если вы хотите узнать больше об этих объектах, вы можете ознакомиться со следующими статьями: Workbook VBA, Worksheet VBA и Cell и Range VBA.

Использование Dim с Class Module Objects

В VBA мы используем Class Modules для создания наших собственных пользовательских объектов. Вы можете прочитать все о Class Modules здесь.

Если мы создаем объект, нам нужно использовать ключевое слово New.

Мы можем сделать это в операторе Dim или в операторе Set.

Следующий код создает объект, используя ключевое слово New в выражении Dim:

' Объявить и создать
Dim o As New class1
Dim coll As New Collection

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

Использование Set дает нам больше гибкости. Мы можем создать много объектов из одной переменной. Мы также можем создать объект на основе условия.

Этот следующий код показывает, как мы создаем объект Class Module, используя Set. (Чтобы создать модуль класса, перейдите в окно проекта, щелкните правой кнопкой мыши соответствующую книгу и выберите «Вставить модуль класса». Подробнее см. «Создание Simple Class Module».)

' Объявить только
Dim o As Class1
' Создать с помощью Set
Set o = New Class1

Давайте посмотрим на пример использования Set. В приведенном ниже коде мы хотим прочитать диапазон данных. Мы создаем объект только в том случае, если значение больше 50.

Мы используем Set для создания объекта Class1. Это потому, что количество нужных нам объектов зависит от количества значений более 50.

Sub IspSet()
    
    ' Объявите переменную объекта Class1
    Dim o As Class1
    
    ' Читать диапазон
    Dim i As Long
    For i = 1 To 10
        If Sheet1.Range("A" & i).Value > 50 Then
            ' Создать объект, если условие выполнено
            Set o = New Class1
            
        End If
    Next i
End Sub

Я сохранил этот пример простым для ясности. В реальной версии этого кода мы бы заполнили объект Class Module данными и добавили его в структуру данных, такую как Collection или Dictionary.

Вот пример реальной версии, основанной на данных ниже:

' Class Module - clsStudent
Public Name As String
Public Subject As String
' Стандартный модуль
Sub ChitatBalli()
    ' Создать коллекцию для хранения объектов
    Dim coll As New Collection
    
    ' Current Region получает соседние данные
    Dim rg As Range
    Set rg = Sheet1.Range("A1").CurrentRegion
    
    Dim i As Long, oStudent As clsStudent
    For i = 2 To rg.Rows.Count
        
        ' Проверьте значение
        If rg.Cells(i, 1).Value > 50 Then
            ' Создать новый объект
            Set oStudent = New clsStudent
            
            ' Читать данные на объект студента
            oStudent.Name = rg.Cells(i, 2).Value
            oStudent.Subject = rg.Cells(i, 3).Value
            
            ' добавить объект в коллекцию
            coll.Add oStudent
            
        End If
        
    Next i
    
    ' Распечатайте данные в Immediate Window, чтобы проверить их
    Dim oData As clsStudent
    For Each oData In coll
        Debug. Print oData.Name & " studies " & oData.Subject
    Next oData
End Sub

Чтобы узнать больше о Set вы можете заглянуть сюда.

Объекты из внешней библиотеки

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

Примерами являются библиотеки Access, Outlook и Word, которые позволяют нам взаимодействовать с этими приложениями.

Мы можем использовать библиотеки для различных типов структур данных, таких как Словарь, Массив, Стек и Очередь.

Существуют библиотеки для очистки веб-сайта (библиотека объектов Microsoft HTML), использования регулярных выражений (регулярные выражения Microsoft VBScript) и многих других задач.

Мы можем создать эти объекты двумя способами:

1. Раннее связывание
2. Позднее связывание

Давайте посмотрим на это по очереди.

Раннее связывание

Раннее связывание означает, что мы добавляем справочный файл. Как только этот файл добавлен, мы можем рассматривать объект как объект модуля класса.

Мы добавляем ссылку, используя Tools-> Reference, а затем проверяем соответствующий файл в списке.

Например, чтобы использовать словарь, мы ставим флажок «Microsoft Scripting Runtime»

Как только мы добавим ссылку, мы можем использовать словарь как объект модуля класса

Sub RanSvyaz()
    ' Используйте только Dim
    Dim dict1 As New Dictionary
    
    ' Используйте Dim и Set
    Dim dict2 As Dictionary
    Set dict2 = New Dictionary
End Sub

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

Лучше всего использовать раннюю привязку при написании кода, а затем использовать позднюю привязку при распространении кода другим пользователям.

Позднее связывание

Позднее связывание означает, что мы создаем объект во время выполнения.

Мы объявляем переменную как тип «Объект». Затем мы используем CreateObject для создания объекта.

Sub PozdSvyaz()
    Dim dict As Object
    Set dict = CreateObject("Scripting.Dictionary")
    
End Sub

В VBA есть два типа массивов:

1. Статический — размер массива задается в операторе Dim и не может изменяться.
2. Динамический — размер массива не указан в выражении Dim. Это устанавливается позже с помощью оператора ReDim

' Статический массив
' Магазины 7 длинных - от 0 до 6
Dim arrLong(0 To 6) As Long
' Магазины 7 длинных - от 0 до 6
Dim arrLong(6) As String

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

Мы объявляем динамический массив, используя инструкцию Dim, и устанавливаем размер позже, используя ReDim.

' Динамический массив
' Объявите переменную
Dim arrLong() As Long
' Установить размер
ReDim arrLong(0 To 6) As Long

Использование ReDim

Большая разница между Dim и ReDim заключается в том, что мы можем использовать переменную в выражении ReDim. В операторе Dim размер должен быть постоянным значением.

Sub IspSet()
    ' Объявите переменную
    Dim arrLong() As Long
    
    ' Спросите пользователя о размере
    Dim size As Long
    size = InputBox("Пожалуйста, введите размер массива.", Default:=1)
    
    ' Установите размер на основе пользовательского ввода
    ReDim arrLong(0 To size) As Long
End Sub

На самом деле мы можем использовать оператор Redim без предварительного использования оператора Dim.

В первом примере вы можете видеть, что мы используем Dim:

Sub IspDimReDim()
    ' Использование Dim
    Dim arr() As String
    ReDim arr(1 To 5) As String
    
    arr(1) = "Яблоко"
    arr(5) = "Апельсин"
    
End Sub

Во втором примере мы не используем Dim:

Sub IspTolkoReDim ()
    ' Использование только ReDim
    ReDim arr(1 To 5) As String
    
    arr(1) = "Яблоко"
    arr(5) = "Апельсин"
    
End Sub

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

Вы можете использовать ключевое слово Preserve с ReDim для сохранения существующих данных при изменении размера массива. Вы можете прочитать больше об этом здесь.

Вы можете найти все, что вам нужно знать о массивах в VBA здесь.

В таблице ниже приведены ошибки, с которыми вы можете столкнуться при использовании Dim. См. Ошибки VBA для объяснения различных типов ошибок.

Ошибка	Тип	Причина
Массив уже рассчитан	Компиляция	Использование Redim для статического массива.
Ожидаемый: идентификатор	Синтаксис	Использование зарезервированного слова в качестве имени переменной.
Ожидаемый: новый тип имени	Синтаксис	Тип отсутствует в выражении Dim.
Переменная объекта или переменная блока не установлена	Время выполнения	New не был использован для создания объекта.
Переменная объекта или переменная блока не установлена	Время выполнения	Set не использовался для назначения переменной объекта.
Пользовательский тип не определен	Компиляция	Тип не распознан. Это может произойти, если ссылочный файл не добавлен в меню «Инструменты-> Ссылка» или имя модуля класса написано неправильно.
Недопустимый оператор вне блока Type	Компиляция	Имя переменной отсутствует в выражении Dim
Переменная не определена	Компиляция	Переменная используется перед Dim-строкой.

Когда мы используем Dim в процедуре (то есть подпрограмме или функции), она считается локальной. Это означает, что это доступно только с этой процедурой.

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

В приведенном ниже коде мы объявили count как глобальную переменную:

' Глобальная
Dim count As Long
Sub UseCount1()
    count = 6
End Sub
Sub UseCount2()
    count = 4
End Sub

Что произойдет, если у нас будет глобальная переменная и локальная переменная с одинаковым именем?

На самом деле это не вызывает ошибку. VBA дает приоритет локальной декларации.

' Глобальная
Dim count As Long
Sub UseCount()
    ' Локальная
    Dim count As Long
    
    ' Относится к локальному счету
    count = 6
    
End Sub

Подобная ситуация может привести только к проблемам, так как трудно отследить, какой счет используется.

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

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

Dim против Private

В VBA есть ключевое слово Private.

Если мы используем ключевое слово Private с переменной или подфункцией / функцией, то этот элемент доступен только в текущем модуле.

Использование Dim и Private для переменной дает тот же результат

' Доступно во всем этом модуле
Private priCount As Long
Dim dimCount As Long
Sub UseCount()
    ' Доступно только в этом разделе
    Private priName As String
    Dim dimName As String
    
End Sub

В VBA принято использовать Private для глобальных переменных и Dim для локальных

' Доступно во всем этом модуле
Private priCount As Long
Sub UseCount()
    ' Только локальный
    Dim dimName As String
    
End Sub

Local OnlyThere в VBA есть 2 других типа объявлений, которые называются Public и Global.

Ниже приводится краткое изложение всех 4 типов:

1. Dim — используется для объявления локальных переменных, т. Е. В процедурах.
2. Private — используется для объявления глобальных переменных и процедур. Эти переменные доступны только для текущего модуля.
3. Public — используется для объявления глобальных переменных и процедур. Эти переменные доступны во всех модулях.
4. Global — старая и устаревшая версия Public. Может использоваться только в стандартных модулях. Он существует только для обратной совместимости.

На этом мы заканчиваем статью о VBA Dim Statement. Если у вас есть какие-либо вопросы или мысли, пожалуйста, дайте мне знать в комментариях ниже.

Объявление переменных. VBA для чайников

ВикиЧтение

VBA для чайников
Каммингс Стив

Содержание

Объявление переменных

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

Dim varAnyOldVariable

Private intIntegerVariable As Integer

Static strNewYearsResolution As String

Обычно в объявлениях используется ключевое слово Dim, возникшее как сокращение от слова Dimension (размер), но как глагол в том смысле, что оператор Dim задает в VBA пространство для хранения данных, на которое будет ссылаться переменная. Точно так же для объявления переменных можно использовать ключевые слова Private, Public и Static:, тем самым сразу объявляя и область видимости таких переменных (подробности ниже, в разделе Задание области видимости переменной, а также в главе 6).

После объявления переменной ее можно использовать в других частях программы. Как правило, сначала с помощью оператора присваивания в переменную помещается некоторая информация (подробно об этом — ниже, в разделе Размещение информации в переменных). Потом эту информацию можно будет извлечь (используя имя переменной) в любой другой части программы.

Объявление переменных

Объявление переменных Перед использованием переменной в коде Web-сценария рекомендуется выполнить ее объявление. Для этого служит оператор объявления переменной var, после которого указывают имя переменной:var x;Теперь объявленной переменной можно присвоить какое-либо

6. Объявление переменных: оператор Dim для различных типов данных

6. Объявление переменных: оператор Dim для различных типов данных Чаще всего люди стараются не пользоваться идентификаторами при обозначении типа переменной (тем более для таких типов, как дата/время). Вместо этого они применяют оператор Dim. Подобная операция называется

Объявление переменных

Объявление переменных Как уже говорилось в главе 6, объявление — это VBA-оператор, с помощью которого вы сообщаете компилятору о своих намерениях использовать именованный объект и явно описываете тип этого объекта. Операторы объявлений чаще всего используются для

Объявление нескольких переменных в одной строке

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

Объявление переменных пользовательского типа

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

Объявление переменных класса

Объявление переменных класса Для объявления переменных, которые понадобятся в нескольких свойствах или методах, используйте раздел Declarations в самом начале модуля класса. Всегда объявляйте эти переменные как локальные ( Private ), ведь объекты в основном предназначены для

Объявление переменных

Объявление переменных В этом разделе дано последовательное описание синтаксиса и семантики объявлений переменных. Разновидности переменных перечислены в следующей таблице:Таблица 3.4. Вид переменной Пояснение Простая переменная Скалярная переменная целого или

Объявление указателя

Объявление указателя Указатель — это переменная, предназначенная для хранения адреса объекта некоторого типа. Указатель на функцию содержит адрес точки входа в функцию.Синтаксис:[<спецификация типа]> *<описатель>;Объявление указателя специфицирует имя

Объявление типа

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

Объявление тега

Объявление тега Объявление типа структуры, объединения или перечислимого типа имеет такую же синтаксическую форму, как и объявление переменной этих типов, однако в объявлении типа идентификатор переменной (а в общем случае описатель) опущен. Именем типа структуры,

Объявление typedef

Объявление typedef Синтаксис:typedef <спецификация типа> <описатель> {,<описатель>…];Объявление typedef синтаксически аналогично объявлению переменной или функции, за исключением того, что вместо спецификации класса памяти записывается ключевое слово typedef и отсутствует

Объявление функции

Объявление функции Объявление функции определяет ее имя, тип возвращаемого значения, класс памяти и может также задавать тип некоторых или всех аргументов функции. Детальное описание синтаксиса объявлений функции дано в разделе 3.5. В разделе 3.6 рассмотрена зависимость

9.4. Объявление переменных: declare и typeset

9.4. Объявление переменных: declare и typeset Инструкции declare и typeset являются встроенными инструкциями (они абсолютно идентичны друг другу и являются синонимами) и предназначена для наложения ограничений на переменные. Это очень слабая попытка контроля над типами, которая

Объявление переменных (VBA) | Microsoft Learn

• Статья
• 22.01.2022
• 5 минут на чтение

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

В следующем примере создается переменная и задается тип данных String.

 Dim strName как строка
 

Если этот оператор появляется в процедуре, переменная strName может использоваться только в этой процедуре. Если инструкция появляется в разделе объявлений модуля, переменная strName доступна для всех процедур в модуле, но не для процедур в других модулях проекта.

Чтобы сделать эту переменную доступной для всех процедур в проекте, поставьте перед ней цифру Оператор Public , как в следующем примере:

 Public strName As String
 

Сведения об именовании переменных см. в разделе правила именования Visual Basic.

Variables can be declared as one of the following data types: Boolean , Byte , Integer , Long , Currency , Single , Double , Date , String ( для строк переменной длины), String * длина (для строк фиксированной длины), Объект или Вариант . Если вы не укажете тип данных, по умолчанию будет назначен тип данных Variant . Вы также можете создать пользовательский тип, используя оператор Type .

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

В следующем операторе переменные intX , intY и intZ объявляются как тип Integer .

 Dim intX как целое число, intY как целое число, intZ как целое число
 

В следующем операторе intX и intY объявлены как тип Variant , и только intZ объявлен как тип Integer .

 Dim intX, intY, intZ Как целое число
 

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

Сокращение для объявления x и y как целого числа в операторе выше:

 Dim intX%, intY%, intZ как целое число
 

Сокращенное обозначение типов: % -integer; & -длинная; @ -валюта; # -двойной; ! -не замужем; $ -string

Используйте оператор Public для объявления общедоступных переменных уровня модуля.

 Общедоступная строка как строка
 

Публичные переменные можно использовать в любых процедурах проекта. Если общедоступная переменная объявлена ​​в стандартном модуле или модуле класса, ее также можно использовать в любых проектах, которые ссылаются на проект, в котором объявлена ​​общедоступная переменная.

Используйте оператор Private для объявления частных переменных уровня модуля.

 Private MyName As String
 

Частные переменные могут использоваться только процедурами в том же модуле.

Примечание

При использовании на уровне модуля оператор Dim эквивалентен оператору Private . Вы можете использовать оператор Private , чтобы упростить чтение и интерпретацию кода.

При использовании Статическая инструкция вместо инструкции Dim для объявления переменной в процедуре объявленная переменная будет сохранять свое значение между вызовами этой процедуры.

Вы можете неявно объявить переменную в Visual Basic, просто используя ее в операторе присваивания. Все неявно объявленные переменные имеют тип Variant . Переменные типа Вариант требуют больше ресурсов памяти, чем большинство других переменных. Ваше приложение будет более эффективным, если вы объявите переменные явно и с определенным типом данных. Явное объявление всех переменных снижает количество ошибок, связанных с конфликтом имен, и орфографических ошибок.

Если вы не хотите, чтобы Visual Basic делал неявные объявления, вы можете поместить оператор Option Explicit в модуль перед любыми процедурами. Этот оператор требует, чтобы вы явно объявили все переменные в модуле. Если модуль включает оператор Option Explicit , возникнет ошибка времени компиляции, когда Visual Basic обнаружит имя переменной, которое ранее не было объявлено или было написано неправильно.

В среде программирования Visual Basic можно установить параметр для автоматического включения Опция Явный оператор во всех новых модулях. См. документацию по вашему приложению, чтобы узнать, как изменить параметры среды Visual Basic. Обратите внимание, что эта опция не изменяет существующий код, который вы написали.

Примечание

Вы должны явно объявлять фиксированные и динамические массивы.

Объявление объектной переменной для автоматизации

Когда вы используете одно приложение для управления объектами другого приложения, вы должны установить ссылку на библиотеку типов другого приложения. После того, как вы установили ссылку, вы можете объявить объектные переменные в соответствии с их наиболее конкретным типом. Например, если вы находитесь в Microsoft Word, когда устанавливаете ссылку на библиотеку типов Microsoft Excel, вы можете объявить переменную типа Worksheet из Word для представления объекта Excel Worksheet .

Если вы используете другое приложение для управления объектами Microsoft Access, в большинстве случаев вы можете объявить объектные переменные в соответствии с их наиболее конкретным типом. Вы также можете использовать ключевое слово New для автоматического создания нового экземпляра объекта. Однако может потребоваться указать, что это объект Microsoft Access. Например, когда вы объявляете объектную переменную для представления формы Access из Visual Basic, вы должны различать Access Объект формы из объекта формы Visual Basic . Включите имя библиотеки типов в объявление переменной, как в следующем примере:

 Dim frmOrders As New Access.Form
 

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

В следующем примере показано, как объявить переменную для представления экземпляра объекта Access Application из приложения, которое не распознает типы объектов Access. Затем приложение создает экземпляр объекта Application .

 Dim appAccess как объект
Установите appAccess = CreateObject("Доступ.Приложение")
 

Чтобы определить, какой синтаксис поддерживает приложение, см. документацию по приложению.

См. также

• Сводка типов данных
• Переменные и константы сводка ключевых слов
• Концептуальные темы Visual Basic

Поддержка и отзывы

У вас есть вопросы или отзывы об Office VBA или этой документации? См. раздел Поддержка и отзывы Office VBA, чтобы узнать, как вы можете получить поддержку и оставить отзыв.

Объявление переменных и присвоение им выражений

Одной из основных целей VBA и (в более общем плане) Excel является работа с данными (и управление ими).

Эти данные обычно хранятся в памяти компьютера. Для целей этого руководства по Excel мы будем различать следующие 2 места для хранения данных:

• Объекты.
• Переменные.

Предыдущая тема (объекты) рассматривается в других руководствах по Excel в рамках Power Spreadsheets, в том числе здесь и здесь. Эта запись в блоге посвящена последней теме (переменные VBA).

Переменные часто используются при работе с Visual Basic для приложений.

У вас есть значительная степень гибкости при объявлении переменных VBA. Эта гибкость в объявлении переменных VBA может привести к плохой практике кодирования. Плохая практика кодирования может привести к потенциальным проблемам в будущем. Эти проблемы могут привести к большой головной боли.

Цель этого руководства по Excel — помочь вам избежать головной боли. Поэтому в этом сообщении блога я объясню наиболее важные аспекты, связанные с объявлением переменных VBA . В частности, это руководство разделено на следующие разделы:

Оглавление

Давайте начнем с подробного рассмотрения…

Что такое переменная VBA

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

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

Это определение может быть дополнительно расширено ссылкой на 3 характеристики переменных . Переменная VBA:

1. — это место хранения в памяти компьютера.
2. Используется программой.
3. Имеет имя.

В свою очередь, эти 3 основные характеристики переменных дают хорошее представление о том, что вам нужно понять, чтобы уметь правильно объявлять переменные в VBA:

1. Как вы определяете способ хранения данных и как вы на самом деле храните данные. Эти элементы относятся к темам типов данных (о которых я расскажу в отдельной статье) и объявлению переменных VBA (о которых я объясню ниже).
2. Как определить, какая программа или часть программы может использовать переменную. Это относится к темам переменного масштаба и жизни.
3. Как назвать переменные VBA.

Ниже я объясню каждый из этих трех аспектов.

В этом учебнике по Excel не рассматривается тема объектных переменных . Это переменная VBA другого типа, которая служит заменой объекта. Я могу, однако, затронуть эту конкретную тему в будущем сообщении в блоге.

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

Почему вы должны явно объявлять переменные в VBA

общие причины в поддержку идеи о том, что вы должны явно объявлять свои переменные VBA при работе с Visual Basic для приложений, давайте начнем с понимания того, что мы на самом деле делаем при явном объявлении переменной . На базовом уровне: когда вы объявляете переменную, компьютер резервирует память для последующего использования.

Общий совет относительно объявления переменных VBA гласит, что объявление переменных — отличная привычка .

Для этого есть несколько причин, но самая сильная связана с типами данных Excel VBA . Ниже приведены основные моменты, которые объясняют, почему, с этой точки зрения, вы должны привыкнуть к объявлению переменных при работе в Visual Basic для приложений:

• Типы данных VBA определяют способ хранения данных в памяти компьютера.
• Вы можете определить тип данных конкретной переменной VBA при ее объявлении. Однако вы также можете не объявлять его и позволить Visual Basic for Applications обрабатывать детали.
• Если не объявить тип данных для переменной VBA, Visual Basic для приложений использует Variant (тип данных по умолчанию).
• Несмотря на то, что он более гибкий, чем другие типы данных, и довольно мощный/полезный в определенных обстоятельствах, постоянное использование Variant имеет некоторые недостатки. Некоторые из этих потенциальных проблем включают неэффективное использование памяти и более медленное выполнение приложений VBA.

Когда вы объявляете переменные в VBA, вы сообщаете Visual Basic for Applications, каков тип данных переменной . Вы больше не полагаетесь на Variant все время. Явное объявление переменных и типов данных может привести к (немного) более эффективным и быстрым макросам.

Хотя приведенное выше, вероятно, является основной причиной, по которой вы должны всегда объявлять переменные в Visual Basic для приложений, это не единственная причина. Давайте рассмотрим других причин, по которым вам следует объявлять переменные при работе с Visual Basic для приложений:

Дополнительная причина №1: объявление переменных позволяет использовать функцию автозаполнения

Давайте рассмотрим следующий фрагмент кода VBA.

Вы можете увидеть весь код VBA макроса Variable_Test ниже.

Это руководство по переменным Excel VBA сопровождается рабочими книгами Excel, содержащими данные и макросы, которые я использую. Вы можете получить немедленный бесплатный доступ к этим примерам книг, подписавшись на информационный бюллетень Power Spreadsheets .

Следующие операторы макроса (после приведенных выше):

MsgBox «значение переменной 1 равно » & Variable_One & _

Chr(13) & «значение второй переменной равно » & Variable_Two

Давайте представим, что вы вводите эти операторы и в данный момент находитесь в следующей точке:

Теоретически, вы должны ввести полное имя переменная: «Variable_One». Однако объявление переменной VBA ранее позволяет воспользоваться сочетанием клавиш: «Ctrl + Space». После того, как вы ввели первые несколько (может быть всего 2 или 3) букв имени объявленной переменной, вы можете нажать «Ctrl + пробел», и редактор Visual Basic выполнит одно из следующих действий:

• Как правило, VBE завершает запись.
• Если доступно более 1 параметра, редактор Visual Basic отображает список возможных совпадений для завершения ввода.

В приведенном выше случае использование сочетания клавиш «Ctrl + пробел» приводит к тому, что редактор Visual Basic отображает список возможных совпадений для завершения записи. Это показано на следующем изображении.

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

Это потому, что та же комбинация клавиш («Ctrl + Space») также работает для этих двух других элементов. Впрочем, это темы для будущих постов в блоге.

Теперь предположим, что вы нажали сочетание клавиш «Ctrl + пробел» в следующем месте:

В этом случае редактор Visual Basic завершает ввод.

Дополнительная причина № 2: объявление переменных заставляет VBA выполнять дополнительную проверку на наличие ошибок

Некоторые ошибки в Visual Basic for Applications бывает очень трудно обнаружить, особенно в больших или сложных приложениях VBA.

Объявляя переменные VBA и определяя их тип данных, вы получаете дополнительную помощь от Visual Basic для приложений. Когда вы явно объявляете тип данных ваших переменных, VBA выполняет дополнительную проверку при компиляции кода. В некоторых из этих случаев VBA может выявить определенные ошибки во время работы над кодом.

Наиболее распространенный тип ошибок, которые VBA может обнаружить таким образом, — это ошибки ввода данных. Эти ошибки вызваны неправильным присвоением определенной информации конкретной переменной. Точнее, это обычно происходит, когда присваивание приводит к несоответствию между следующим:

• Тип данных переменной; и
• Тип данных, присвоенных переменной.

Ниже приведены некоторые примеры того, как это может произойти:

• Вы объявляете целочисленную или байтовую переменную, но пытаетесь присвоить ей строку. Типы данных Integer и Byte предназначены для хранения определенных целых чисел, а не строк.
• Вы объявляете логическую переменную, но пытаетесь присвоить ей большое целое число. Переменные с типом данных Boolean могут принимать только 2 логических значения (TRUE и FALSE).

Надлежащее объявление ваших переменных VBA (обычно) позволяет вам заметить такого рода ошибки как можно скорее после того, как переменная получит непредвиденный тип данных.

Дополнительная причина № 3: объявление переменных улучшает читаемость кода, упрощает отладку и снижает риск некоторых ошибок или процедура. Это улучшает читаемость вашего кода VBA.

Кроме того, явное объявление переменных упрощает отладку и редактирование кода VBA.

Наконец, привыкание всегда объявлять переменные явно, следуя различным предложениям, которые появляются в этом руководстве по Excel, снижает риск определенных ошибок. Помимо прочего, явное объявление переменных снижает риск возникновения следующих проблем:

• Ошибки конфликта имен переменных; и
• Орфографические или типографские ошибки.

Ошибки конфликта имен весьма опасны. Если вы не объявляете переменные VBA, существует более высокий риск случайной перезаписи или уничтожения уже существующей переменной при попытке создать новую.

Орфографические ошибки также могут создать большие проблемы. Ниже я объясню один из основных способов, с помощью которого принятие мер по объявлению переменных всегда поможет вам уменьшить количество орфографических ошибок.

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

Чтобы увидеть, как это работает, вернемся к коду VBA для макроса Variable_Test. Предположим, что вы ввели имя Variable_One без заглавных букв (как показано ниже):

После завершения инструкции редактор Visual Basic автоматически делает соответствующие буквы заглавными. Это выглядит следующим образом:

Вы можете, например, сделать привычкой (i) использовать некоторые заглавные буквы в именах переменных VBA, но (ii) набирать тело кода VBA только строчными буквами. буквы. Если редактор Visual Basic не пишет имя переменной с заглавной буквы после того, как вы его ввели, возможно, вы ввели имя неправильно. VBE (как правило) автоматически использует заглавные буквы для всех ключевых слов (а не только для переменных VBA).

Все преимущества, которые я перечисляю в разделе «Дополнительная причина №3», в конечном счете связаны с тем фактом, что объявление переменных помогает вам (и самому VBA) лучше понять, какие переменные существуют в любой конкретный момент времени.

Поэтому я предлагаю вам избавить себя от некоторых потенциальных проблем, привыкнув к явному объявлению ваших переменных VBA.

Недостаток явного объявления переменных VBA

Несмотря на преимущества, описанные выше, идея всегда объявлять переменные VBA явно не принимается безоговорочно .

Большинство пользователей VBA согласны с тем, что явное объявление переменных (обычно) является хорошей идеей.

Однако некоторые пользователи VBA утверждают, что оба подхода имеют свои преимущества и недостатки. С этой точки зрения основным недостатком явного объявления переменных является тот факт, что оно требует некоторого времени и усилий. В большинстве случаев эти недостатки (обычно) перевешиваются преимуществами явного объявления переменных.

Однако на практике кажется, что для нескольких программистов VBA тот факт, что объявление переменных требует немного больше времени и усилий, не перевешивается преимуществами, описанными выше. Фактически, некоторые разработчики не объявляют переменные явно.

Ниже я привожу общее объяснение того, как создать переменную VBA без ее объявления (так называемое неявное объявление переменной).

Однако предположим на данный момент, что вы убеждены в преимуществах объявления переменных VBA. Вы хотите делать это всегда: больше никаких необъявленных переменных.

Чтобы убедиться, что вы выполняете все, вам может быть интересно узнать…

Как не забывать объявлять переменные

Visual Basic для приложений имеет особое выражение, которое заставляет вас объявлять любые переменные, которые вы используете . Это называется оператором Option Explicit.

Всякий раз, когда оператор Option Explicit находится в модуле, вам запрещается выполнять код VBA, содержащий необъявленные переменные .

Оператор Option Explicit необходимо использовать только один раз для каждого модуля. Другими словами:

• Вы включаете только 1 оператор Option Explicit на модуль.
• Если вы работаете над конкретным проектом VBA, который содержит более 1 модуля, в каждом модуле должен быть 1 оператор Option Explicit.

Включить оператор Option Explicit в модуль довольно просто:

Просто введите «Option Explicit» в начале соответствующего модуля и перед объявлением каких-либо процедур . На следующем рисунке показано, как это выглядит:

После включения инструкции Option Explicit в модуль Visual Basic для приложений не выполняет процедуру внутри этого модуля, если не объявлены абсолютно все переменные в этой процедуре. Если вы попытаетесь вызвать такую ​​процедуру, Excel отобразит следующее сообщение об ошибке времени компиляции:

В дополнение к причинам, которые я приводил выше, чтобы поддержать идею о том, что вы должны объявлять свои переменные VBA, есть дополнительное преимущество при использовании оператор Option Explicit и необходимость объявлять абсолютно все ваши переменные :

Редактор Visual Basic автоматически проверяет написание имен переменных VBA .

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

Вернемся к макросу Variable_Test, который я представил выше. На следующем снимке экрана показана полная процедура Sub:

Обратите внимание, как в начале процедуры Sub объявляются переменные Variable_One и Variable_Two. Ниже я объясню, как объявить переменные VBA.

Кроме того, обратите внимание, как каждая из этих переменных появляется 2 раза после объявления:

Предположим, что при написании кода VBA вы допустили опечатку при написании имени переменной VBA Variable_One (вы набрали « Variable_O m e»). В таком случае код макроса Variable_Test выглядит следующим образом:

Такие небольшие опечатки бывает трудно обнаружить в определенных ситуациях. Это имеет место, например, если они присутствуют в коде VBA большой процедуры Sub или Function, где вы работаете с несколькими различными переменными. Это может быть большой проблемой…

Если вы не заметите такого рода опечатки в именах переменных, Excel интерпретирует разные варианты написания как разные переменные (например, Variable_One и Variable_Ome). Другими словами, Excel создает новую переменную, используя имя с ошибкой. Это приводит к тому, что у вас есть несколько переменных, даже если вы думаете, что у вас есть только одна, и в некоторых случаях это может привести к тому, что макрос вернет неправильный результат .

Однако, , если вы неправильно напишете имя переменной VBA при включенном операторе Option Explicit, Excel предупредит вас об этом . На следующем изображении показано сообщение об ошибке, которое отображается, когда я пытаюсь запустить макрос Variable_Test с опечаткой, показанной выше. Обратите внимание на то, как редактор Visual Basic:

• ясно информирует вас о наличии неопределенной переменной.
• Выделяет элемент кода VBA, в котором содержится ошибка.

Использование явного оператора Option (обычно) рекомендуется .

Поэтому давайте сделаем еще один шаг и посмотрим, как убедиться, что оператор Option Explicit всегда включен:

Как не забывать объявлять переменные всегда

Оператор Option Explicit не включен по умолчанию . Это означает, что если вы хотите использовать его всегда, вам придется включать его для каждого отдельного модуля, который вы создаете.

Однако редактор Visual Basic обладает широкими возможностями настройки. Одна из настроек, которые вы можете сделать, это сделать так, чтобы VBE всегда требовал, чтобы вы объявляли свои переменные . Редактор Visual Basic делает это, автоматически вставляя оператор Option Explicit в начале любого модуля VBA.

Включение этой опции обычно рекомендуется . Если вы хотите, чтобы редактор Visual Basic вставлял оператор Option Explicit во все ваши будущие модули, выполните следующие 2 простых шага:

Шаг № 1: откройте диалоговое окно параметров

Вы можете открыть диалоговое окно «Параметры» редактора Visual Basic щелкнув меню «Инструменты» и выбрав «Параметры…».

Шаг № 2: Включите «Требовать объявление переменной» и нажмите кнопку «ОК»

Редактор Visual Basic должен отображать вкладку «Редактор» диалогового окна «Параметры» по умолчанию. В противном случае просто щелкните соответствующую вкладку в верхней части диалогового окна.

На вкладке «Редактор» вам просто нужно включить «Требовать объявление переменной», установив флажок рядом с ним. Затем нажмите кнопку OK в правом нижнем углу диалогового окна, чтобы завершить операцию.

Обратите внимание, что включение параметра Требовать объявление переменной применимо только к модулям, созданным в будущем . Другими словами, Require Variable Declaration не вставляет оператор Option Explicit в ранее существующие модули, которые были созданы, когда этот параметр не был включен.

Вы можете узнать больше о настройке редактора Visual Basic в диалоговом окне «Параметры», включая подробное описание параметра «Требовать объявление переменной», нажав здесь.

Вы уже знаете, как определить способ хранения данных с помощью типов данных VBA. Давайте посмотрим, как вы на самом деле храните данные или, другими словами…

Как объявить переменную в VBA

Самый распространенный способ явного объявления переменной — использование оператора Dim . На практике вы, скорее всего, будете использовать Dim для большинства объявлений ваших переменных.

Вы уже видели этот тип оператора в макросе Variable_Test, показанном выше. В этом конкретном случае оператор Dim используется для объявления переменных Variable_One и Variable_Two следующим образом:

Обе переменные объявляются как имеющие тип данных Integer.

3 другие ключевые слова (помимо Dim) могут использоваться для явного объявления переменной VBA :

1. Статич.
2. Общедоступный.
3. Частный.

Как объяснено ниже, вы обычно используете эти 3 последних оператора для объявления переменных с особыми характеристиками, касающимися их области действия или времени жизни.

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

Ключевое слово Variable_Name As Data_Type

В этой структуре:

• «Ключевое слово» — любое из перечисленных выше ключевых слов: Dim, Static, Public или Private. В следующих разделах я объясню, когда уместно использовать каждый из них.
• «Имя_переменной» — это имя, которое вы хотите присвоить переменной. Ниже я объясню, как называть переменные VBA.
• «Data_Type» ссылается на тип данных переменной. Этот элемент является необязательным, но рекомендуемым.

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

В следующей таблице показана взаимосвязь между 4 различными операторами, которые вы можете использовать для объявления переменной VBA, и 3 различными областями действия, которые может иметь переменная :

В следующих разделах я представлю операторы Dim, Static, Private и Public. Однако, когда вы читаете их описания, вы можете постоянно обращаться к разделу ниже, в котором рассматривается область действия переменных VBA.

Как объявить переменную VBA с помощью оператора Dim

Оператор Dim является наиболее распространенным способом объявления переменной VBA, областью действия которой является уровень процедуры или уровень модуля 9.0016 . Ниже я расскажу об области видимости переменной.

Dim обозначает размер. В старых версиях BASIC этот оператор (Dim) использовался для объявления размеров массива.

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

На изображении выше показан самый простой способ использования оператора Dim для объявления переменных VBA. Однако вы также можете использовать один оператор Dim для объявления нескольких переменных . В таких случаях вы используете запятую для разделения различных переменных.

На следующем снимке экрана показано, как можно объявить Variable_One и Variable_Two (используемые в примере макроса Variable_Test) с помощью одного оператора Dim: ) делает код менее читаемым .

Независимо от того, объявляете ли вы переменные VBA в отдельных строках или в одной строке, обратите внимание, что вы не можете объявить несколько переменных определенного типа данных, просто разделив переменные запятой перед объявлением одного типа данных . Как объясняется в Excel 2013 Power Programming with VBA:

В отличие от некоторых языков, VBA не позволяет объявлять группу переменных как определенный тип данных, разделяя переменные запятыми.

Другими словами, следующее утверждение не эквивалентно приведенному выше:

В этом последнем случае только Variable_Two объявляется как целое число.

В случае Variable_One этот фрагмент кода не объявляет тип данных VBA. Поэтому Visual Basic для приложений использует тип по умолчанию: Variant.

Расположение оператора Dim в модуле VBA зависит от желаемой области действия переменной . Ниже я объясню тему переменной области видимости и того, где разместить операторы Dim в зависимости от ваших планов.

Как объявить переменную с помощью оператора Static

Вы можете использовать оператор Static для объявления переменных VBA уровня процедуры . Это альтернатива оператору Dim.

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

Основное различие между переменными VBA, объявленными с помощью оператора Dim, и переменными, объявленными с помощью оператора Static, заключается в моменте сброса переменной . Давайте посмотрим, что именно это означает:

Как правило (при объявлении с помощью оператора Dim), все переменные уровня процедуры сбрасываются по завершении соответствующей процедуры. Статические переменные не сбрасываются; они сохраняют значения между вызовами процедуры .

Однако статические переменные VBA сбрасываются при закрытии книги Excel, в которой они хранятся. Они также сбрасываются (как я объясню ниже), когда процедура завершается оператором End.

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

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

• Сохранение данных для процедуры, которая позже снова выполняется и использует эту информацию.
• Отслеживание (подсчет) промежуточной суммы.

Давайте быстро взглянем на эти 2 примера:

Пример #1: Переключение

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

Рассмотрим, например, процедуру, которая включает и выключает форматирование полужирным шрифтом. Поэтому:

• При первом вызове процедуры включено жирное форматирование.
• Во втором исполнении полужирное начертание отключено.
• Для третьего вызова снова включается полужирное начертание.
• И так далее…

Пример #2: Счетчики

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

• Объявив переменную счетчика как статическую переменную VBA.
• Увеличение значения, присвоенного статической переменной, на 1 при каждом вызове процедуры.

Как объявить переменную VBA с помощью операторов Private и Public

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

Четвертый и последний оператор, который можно использовать для объявления переменной VBA как общедоступной. Оператор Public используется для объявления общедоступных переменных . Ниже я объясню общедоступные переменные.

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

Как определить область действия переменной VBA

Область действия переменной VBA определяет, какие модули и процедуры могут использовать эту конкретную переменную . Другими словами, он определяет, где можно использовать эту переменную.

Понимание того, как определить область действия переменной, очень важно, потому что:

• В одном модуле может быть несколько процедур.
• В одной книге Excel может быть несколько модулей.

Если вы работаете с относительно простыми приложениями VBA, у вас может быть только один модуль с несколькими процедурами. Однако по мере того, как ваша работа с VBA становится все более сложной и изощренной, это может измениться.

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

Кроме того, область действия переменной VBA имеет важные последствия в связи с другими характеристиками переменной. Примером этого является жизнь переменной, тему, которую я объясню ниже.

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

Область переменной № 1: переменные уровня процедуры (или локальные) VBA

Это самая ограниченная область действия переменной.

Как следует из названия, переменные уровня процедуры (также известные как локальные переменные) могут использоваться только внутри процедуры, в которой они объявлены . Это относится как к процедурам Sub, так и к функциям.

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

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

Это важный момент: как правило, вы должны делать свои переменные VBA как можно более локальными . Или, другими словами: ограничьте область действия переменной до уровня/области, в которой они вам нужны.

Excel не сохраняет значения, присвоенные переменным VBA уровня процедуры, для использования или доступа вне соответствующей процедуры. Поэтому при повторном вызове той же процедуры все предыдущие значения переменных уровня процедуры теряются.

Статические переменные (которые я объясняю выше) являются, однако, исключением из этого правила . Обычно они сохраняют свои значения после завершения процедуры.

Давайте посмотрим, как вы объявляете переменную уровня процедуры:

Как я объяснял выше, обычным способом объявления переменной VBA является использование оператора Dim. Это общее правило применяется к переменным уровня процедуры.

Вы также можете использовать оператор Static для объявления переменной уровня процедуры. В таком случае вы просто используете ключевое слово Static вместо ключевого слова Dim при объявлении переменной VBA. Обычно вы используете оператор Static вместо Dim, если вам нужно, чтобы переменная сохраняла свое значение после завершения процедуры .

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

Единственным строгим требованием в отношении расположения оператора объявления переменной внутри процедуры является то, что он должен быть до точки, в которой вы используете эту конкретную переменную VBA . На практике большинство пользователей VBA объявляют все переменные в начале применимой процедуры.

Точнее, наиболее распространенное расположение оператора объявления переменной в процедуре:

• Сразу после оператора объявления соответствующей процедуры.
• Перед основной частью заявлений соответствующей процедуры.

Код VBA макроса Variable_Test является хорошим примером того, как вы обычно объявляете переменную VBA с помощью оператора Dim. Обратите внимание, что оператор Dim, используемый для объявления обеих переменных (Variable_One и Variable_Two), находится между оператором объявления процедуры Sub и основным телом операторов:

Как вы понимаете, размещение всех операторов объявления переменных VBA в начале процедуры делает код более читабельным.

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

Я объясняю это только в иллюстративных целях, а не для того, чтобы рекомендовать вам повторять имена переменных VBA в ваших процедурах. Повторение имен переменных в разных процедурах (внутри одного и того же проекта) может быстро привести к путанице. Это имеет место, в частности, при отладке этих процедур. Как вы узнаете ниже, общая рекомендация по выбору имени переменной — использовать уникальные имена переменных .

Давайте посмотрим, как это работает на практике, вернувшись к модулю, содержащему процедуру Variable_Test Sub, и добавив вторую (почти идентичную процедуру): Variable_Test_Copy.

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

Если я запускаю макрос Variable_Test, Excel отображает следующее окно сообщения :

Если я запускаю макрос Variable_Test_Copy, Excel отображает очень похожее окно сообщения. Обратите внимание, в частности, как изменяются значения первой и второй переменных:

Давайте перейдем к более широкой области видимости переменных:

Область действия переменной № 2: Уровень модуля (также известная как частная) Переменные VBA

Идеи, лежащие в основе Концепция переменных уровня модуля (также известных как частные) переменных VBA в определенной степени аналогична тому, что вы уже видели в отношении переменных уровня процедуры (с некоторыми вариациями).

Как следует из их названия, переменные уровня модуля доступны для использования в любой процедуре внутри модуля, в котором переменная VBA объявлена ​​ . Таким образом, переменные уровня модуля сохраняются после завершения конкретной процедуры. Однако они недоступны для процедур в других модулях того же проекта VBA.

Как следствие вышеизложенного, Excel сохраняет значения, присвоенные переменным уровня модуля, для использования или доступа в соответствующем модуле. Следовательно, Переменные уровня модуля сохраняют свои значения между процедурами, если эти процедуры находятся в одном и том же модуле . Переменные уровня модуля позволяют передавать данные между процедурами, хранящимися в одном модуле.

Несмотря на вышеизложенное, переменные уровня модуля не сохраняют свои значения между процедурами (даже если они находятся в одном модуле), если имеется оператор End. Как я объясню ниже, переменные VBA очищаются и теряют свои значения, когда VBA встречает такой оператор.

Самый распространенный способ объявления переменных VBA на уровне модуля — использование оператора Dim . Кроме того, вы можете использовать оператор Private.

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

Однако некоторые опытные пользователи VBA предполагают, что с использованием оператора Private может быть лучшей альтернативой для объявления переменных уровня модуля . Причина этого в том, что, поскольку вы обычно используете оператор Dim для объявления переменных уровня процедуры, использование другого ключевого слова (Private) для объявления переменных уровня модуля делает код более читабельным, позволяя различать переменные уровня процедуры. и переменные уровня модуля легко.

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

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

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

В случае с примерами книг Excel, которые прилагаются к этому руководству, в разделе «Объявления» появляется оператор Option Explicit.

При работе в любом модуле VBA вы можете легко перейти к разделу объявлений в среде Visual Basic, щелкнув раскрывающийся список в правом верхнем углу окна кода (известный как окно процедуры) и выбрав «(Декларации)».

В этом же раскрывающемся списке продолжает отображаться «(Объявления)», пока вы работаете в разделе «Объявления» соответствующего модуля.

Давайте посмотрим на практические последствия работы с переменными уровня модуля, изменив приведенный выше код VBA следующим образом:

• Создание переменных уровня модуля Variable_One и Variable_Two путем объявления их в разделе объявлений.
• Удаление инструкций, которые присваивали значения Variable_One и Variable_Two в макросе Variable_Test_Copy. Назначение, сделанное в подпроцедуре Variable_Test, сохраняется.

Результирующий код VBA выглядит следующим образом:

При выполнении макроса Variable_Test Excel отображает следующее окно сообщения:

Ниже показано окно сообщения, отображаемое при выполнении макроса Variable_Test_Copy. Обратите внимание, что обе переменные (Variable_One и Variable_Two):

• Могут использоваться в обеих процедурах в соответствующем модуле.
• Сохранены значения, назначенные макросом Variable_Test, для использования в макросе Variable_Test_Copy.

Теперь давайте взглянем на третий тип области действия переменной:

Область действия переменной № 3: Общедоступные переменные VBA

Доступность общедоступных переменных VBA даже шире, чем у переменных уровня модуля:

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

Переменные, объявленные с помощью оператора Public, видны всем процедурам во всех модулях, если только не применяется Option Private Module. Если включен Option Private Module, переменные доступны только в том проекте, в котором они объявлены.

Принимая решение о работе с общедоступными переменными VBA, помните общее правило, которое я описал выше: делайте переменные VBA как можно более локальными .

Давайте начнем с рассмотрения основного случая:

Как объявить общедоступные переменные VBA: основы

Чтобы объявить общедоступную переменную VBA , объявление должно соответствовать следующим условиям: в разделе «Объявления», как если бы вы объявляли переменную уровня модуля.

Объявление должно быть сделано в стандартном модуле VBA.

Переменные VBA, объявления которых соответствуют этим условиям , доступны для любой процедуры (даже в разных модулях) в пределах одной книги Excel .

Чтобы увидеть, как это работает, вернемся к макросам выше: макросам Variable_Test и Variable_Test_Copy и посмотрим, как переменные (Variable_One и Variable_Two) должны быть объявлены, чтобы стать общедоступными.

В этом примере я сначала сохраняю оба макроса в разных модулях. Обратите внимание, как на снимке экрана ниже в Project Explorer показаны 2 модуля.

Module1 хранит макрос Variable_Test, а Module2 хранит макрос Variable_Test_Copy. Переменные объявлены в Module1.

Это руководство по переменным Excel VBA сопровождается книгами Excel, содержащими данные и макросы, которые я использую (включая макросы выше). Вы можете получить немедленный бесплатный доступ к этим примерам книг, подписавшись на информационный бюллетень Power Spreadsheets .

Обратите внимание, как на снимке экрана выше обе переменные объявляются с помощью оператора Dim. Следовательно, в нынешнем виде они являются переменными уровня модуля. Если я попытаюсь выполнить макрос Variable_Test_Copy (у которого теперь нет ни объявления переменной, ни назначения), который хранится в Module2, Excel вернет следующее сообщение об ошибке:

оператор Option Explicit и причины, по которым вы всегда должны объявлять переменные.

Вернемся к Module1, где объявлены Variable_One и Variable_Two, и изменим ключевое слово, используемое для их объявления. Вместо Dim мы используем Public. В остальном макрос остается без изменений.

Если я снова запущу оба макроса (Variable_Test и Variable_Test_Copy) в том же порядке, что и выше, в окнах сообщений, отображаемых Excel, теперь будут отображаться те же значения. Точнее:

• При выполнении Variable_Test Excel отображает следующее окно сообщения:

• И, поскольку теперь переменные объявляются с помощью оператора Public, Excel отображает следующее при вызове макроса Variable_Test_Copy (который не объявляет переменные и не присваивает им значения).

Как показано на снимках экрана выше:

• Обе переменные теперь доступны для всех процедур в соответствующей книге, даже если они хранятся в отдельных модулях.
• Переменные сохраняют значения, назначенные первым макросом (Variable_Test), для использования вторым макросом (Variable_Test_Copy).

Этот базовый метод объявления общедоступных переменных VBA на практике является единственным, который вам действительно нужно знать. Однако, если вам интересно, давайте взглянем на…

Как объявить общедоступные переменные VBA, доступные в разных книгах

На практике вы, скорее всего, будете использовать только общедоступные переменные VBA, которые доступны для всех процедур внутри конкретная книга Excel , в которой объявлена ​​переменная. Это метод, который я описал в предыдущем разделе.

Однако также можно сделать общедоступные переменные VBA доступными для процедур внутри модулей, хранящихся в разных книгах Excel. Это редко требуется (или делается).

Вы создаете переменную, доступную для модулей, хранящихся в книгах Excel, отличных от той, в которой переменная фактически объявлена ​​, выполнив следующие 2 простых шага:

• Шаг № 1: Объявите переменную как общедоступную, следуя указания в предыдущем разделе.
• Шаг № 2: Создайте ссылку на книгу Excel, в которой объявлена ​​соответствующая переменная. Вы можете настроить ссылку с помощью команды «Ссылки» в редакторе Visual Basic. Эта команда появляется в меню «Инструменты» VBE.

Как правило, область действия переменной определяет время ее жизни. Поэтому давайте взглянем на…

Что такое срок жизни переменной VBA и как он определяется

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

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

Другими словами: Срок службы переменной VBA (обычно) зависит от ее области действия .

К счастью, тема переменной жизни проще, чем тема масштаба. Точнее есть 2 основных правила :

• Правило №1: Переменные VBA уровня процедуры, объявленные с помощью инструкции Dim, удаляются из памяти после завершения соответствующей процедуры.
• Правило №2: Уровень процедуры Статические переменные, переменные уровня модуля и общедоступные переменные сохраняют свои значения между вызовами процедур.

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

• Метод №1: Нажмите кнопку Сброс.

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

  
  
• Способ № 2: Нажмите «Конец», когда отобразится диалоговое окно «Ошибка во время выполнения».

  На следующем изображении показана ошибка времени выполнения, вызванная попыткой выполнить макрос для удаления строк, если в указанном диапазоне есть пустые ячейки без обработчика ошибок On Error Resume Next, который необходим в этом случае. Кнопка End расположена в нижней части диалогового окна.

• Способ №3: Включите оператор End в свой код VBA.

  С широкой точки зрения оператор End имеет различные синтаксические формы. Тем не менее, я имею в виду просто «Конец». Вы можете поместить этот оператор End в любое место вашего кода.

  Оператор End может иметь несколько последствий, таких как прекращение выполнения кода и закрытие файлов, которые были открыты с помощью оператора Open. Для целей этого учебника по Excel наиболее важным последствием использования оператора End является то, что он удаляет переменные из памяти.

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

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

Теперь, когда мы полностью рассмотрели вопрос о том, как определить, какое приложение или часть приложения может использовать переменную (рассмотрев темы, посвященные области действия и жизни переменных VBA), давайте разберемся…

Как присвоить имена переменным VBA

Visual Basic для приложений предоставляет большую гибкость в отношении того, как вы можете называть переменные . Как правило, правила, применяемые к именованию переменных, по существу аналогичны правилам, применяемым к большинству других элементов в Visual Basic for Applications.

Основные правила , которые применяются к именованию переменных VBA, можно резюмировать следующим образом . Я также освещаю тему именования (в контексте процедур именования) в Visual Basic for Applications здесь и здесь, а также в других местах.

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

  Одним из наиболее часто используемых знаков препинания является подчеркивание (_). Некоторые программисты VBA используют его для улучшения читаемости имен переменных VBA. В целях иллюстрации взгляните на имена макросов, которые я использую в этом сообщении блога. Другие пользователи VBA опускают знак подчеркивания и используют имена переменных смешанного регистра (как объяснено ниже). 9или *), операторы сравнения (такие как =, < или >) или определенные знаки препинания (такие как символы объявления типа @, #, $, %, & и !, которые я объясню ниже).

• Имена переменных VBA не могут совпадать с именами любых зарезервированных ключевых слов Excel. Эти зарезервированные ключевые слова включают Sub, Dim, With, End, Next и For.

  Если вы попытаетесь использовать любое из этих слов, Excel вернет сообщение об ошибке синтаксиса. Эти сообщения не очень описательные. Таким образом, , если вы получаете странное сообщение об ошибке компиляции, может быть хорошей идеей подтвердить, что вы не используете зарезервированное ключевое слово для имени какой-либо из ваших переменных VBA .

  Вы можете (теоретически) использовать имена, соответствующие именам в объектной модели Excel VBA (например, Workbook, Worksheet и Range). Однако это увеличивает риск путаницы. Поэтому обычно рекомендуется избегать использования таких имен переменных.

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

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

• Visual Basic для приложений не различает прописные и строчные буквы. Например, «А» — это то же самое, что «а».

  Независимо от этого правила, некоторые программисты VBA используют имена переменных смешанного регистра для удобства чтения. Например, взгляните на имена переменных, используемые в примере макроса № 5, такие как aRow и BlankRows.

  Некоторые опытные пользователи VBA считают, что лучше начинать имена переменных со строчных букв. Это снижает риск перепутать эти имена со встроенными ключевыми словами VBA.

• Максимальное количество символов, которое может содержать имя переменной VBA, равно 255. Однако, как упоминалось в документе Power Programming Excel 2013 с VBA , очень длинные имена переменных не рекомендуются.
• Имя каждой переменной VBA должно быть уникальным в соответствующей области. Это означает, что имя переменной уровня процедуры должно быть уникальным в пределах соответствующей процедуры, имя переменной уровня модуля должно быть уникальным в пределах своего модуля и так далее.

  Это требование имеет смысл, если учесть, насколько важно убедиться, что Visual Basic для приложений использует правильную переменную (а не путать ее с другой).

  На более общем уровне имеет смысл иметь (почти) всегда уникальные имена . Как я объяснял выше, повторное использование имен переменных может сбивать с толку при отладке. Некоторые продвинутые пользователи VBA считают, что из этого правила есть разумные исключения, например, некоторые управляющие переменные.

В дополнение к этим правилам и предложениям, связанным с этими правилами, вы можете найти несколько дополнительных методов или предложений, сделанных экспертами Excel ниже.

Например, одно из наиболее распространенных предложений относительно именования переменных VBA — сделать имена переменных описательными .

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

Наконец, продвинутые пользователи VBA  предлагают добавлять префикс к именам переменных VBA для идентификации их типа данных . Эти пользователи утверждают, что добавление этих префиксов делает код более читаемым и легким для изменения, поскольку все переменные можно легко идентифицировать как относящиеся к определенному типу данных во всем коде VBA.

В следующей таблице показаны основные теги, которые применяются к переменным VBA:

Тип данных	Префикс
Логический	млрд
Валюта	курс
Двухместный	Двухместный
Целое число	Целое число
Длинный	Длинный
Одноместный	Одноместный
Строка	ул
Тип (определяется пользователем)	тип.
Вариант	Вариант

В Excel 2013 Power Programming with VBA Джон Уокенбах вводит аналогичное соглашение об именах. В этом случае соглашение требует использования префикса нижнего регистра, указывающего тип данных. В следующей таблице показаны эти префиксы (некоторые из них совпадают с указанными в таблице выше):

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

В конце концов вы разработаете свой собственный метод именования переменных, который вам подойдет. Более важным, чем следование идеям других пользователей VBA, является разработка и (последовательное) использование некоторых соглашений об именах переменных . Пожалуйста, не стесняйтесь использовать любые идеи и предложения, которые появляются (или связаны) выше, при создании вашей системы именования переменных…

И обязательно сообщите мне о своем опыте и идеях до , оставив комментарий ниже .

Приведенные выше разделы охватывают все основные элементы оператора объявления переменной VBA. Давайте кратко рассмотрим, что происходит после того, как вы объявили переменную, поняв…

Как присвоить значение или выражение переменной VBA

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

• Значение по умолчанию для числовых типов данных (таких как Byte, Integer, Long, Currency, Single и Double) равно 0.
• В случае переменных строкового типа (таких как String и Date) значением по умолчанию является пустая строка («») или код ASCII 0 (или Chr(0)). Это зависит от того, является ли длина строки переменной или фиксированной.
• Для переменной Variant значение по умолчанию — Empty. Представление пустого значения зависит от контекста:
  • В числовом контексте пустое значение представлено 0.
  • В строковом контексте это представляется строкой нулевой длины («»).

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

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

Операторы присваивания принимают значение или выражение (выводящее строку, число или объект) и присваивают его переменной VBA или константе .

Вы, наверное, заметили, что нельзя объявить переменную VBA и присвоить ей значение или выражение в одной строке. Поэтому в Visual Basic для приложений операторы присваивания отделены от операторов объявления переменных.

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

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

В Visual Basic for Applications выражений можно рассматривать как имеющие 3 основные характеристики :

• Они состоят из комбинации одного или нескольких из следующих 4 элементов:
  • Элемент №1: ключевых слов.
  • Элемент №2: операторов.
  • Элемент №3: переменных.
  • Элемент №4: Константы.
• Их результат является одним из следующих 3 пунктов:
  • Товар №1: Строка.
  • Пункт №2: Номер.
  • Предмет №3: Объект.
• Их можно использовать для любой из следующих 3 целей:
  • Цель №1: Выполнение расчетов.
  • Цель №2: Управление символами.
  • Цель №3: Тестовые данные.

Выражения не особенно сложны. Основное различие между формулами и выражениями заключается в том, что вы с ними делаете:

• При использовании формул рабочего листа Excel отображает результат, который они возвращают, в ячейке.
• При использовании выражений можно использовать Visual Basic для приложений, чтобы присвоить результат переменной VBA.

Как правило, вы используете знак равенства (=) для присвоения значения или выражения переменной VBA . Другими словами, знак равенства (=) — это оператор присваивания.

При использовании в этом контексте знак равенства (=) не означает равенство. Другими словами, знак равенства (=) просто оператор присваивания, а не математический символ, обозначающий равенство.

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

• Справа от знака равенства: значение или выражение, которое вы сохраняете.
• Слева от знака равенства: переменная VBA, в которой вы сохраняете данные.

Вы можете изменить значение или выражение, присвоенное переменной во время выполнения приложения .

Чтобы закончить этот раздел об операторах присваивания, давайте кратко рассмотрим присваивания, сделанные в примерах макросов Variable_Test и Variable_Test_Copy. На следующем изображении показано, как выполнялись эти (довольно простые) задания.

Обратите внимание на использование знака равенства (=) в обоих случаях. В обоих макросах Variable_Test и Variable_Test_Copy значение, отображаемое справа от знака равенства, присваивается переменной, отображаемой слева от знака.

К настоящему моменту мы рассмотрели почти все основы, связанные с объявлением переменных в Visual Basic для приложений. Однако вам может быть интересно…

Что, если я не хочу следовать приведенным выше предложениям и не хочу явно объявлять переменные?

В следующем разделе объясняется, как это сделать…

Как неявно объявлять переменные VBA (т. е. как создавать переменные без их объявления)

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

Однако на самом деле это не всегда возможно или удобно. На практике некоторые разработчики VBA не объявляют переменные явно. Фактически, эти разработчики имеют тенденцию (просто) создавать переменные по мере необходимости (и когда).

Это относительно просто и называется неявным объявлением переменной. С практической точки зрения, означает использование переменной VBA в операторе присваивания без предварительного объявления в явном виде (как объясняется в большей части этого сообщения в блоге). Это работает, потому что, когда VBA встречает имя, которое он не распознает (например, как переменную, зарезервированное слово, свойство или метод), он создает новую переменную VBA, используя это имя.

Давайте рассмотрим практический пример, вернувшись к макросам Variable_Test и Variable_Test_Copy…

На изображении ниже показан код VBA макросов Variable_Test и Variable_Test_Copy без явного объявления Variable_One и Variable_Two. Обратите внимание, что нет оператора Dim, как на изображении выше. Обе процедуры VBA Sub начинаются с простого присвоения значения соответствующим переменным.

Когда это произойдет, Visual Basic for Applications работает следующим образом :

• Шаг № 1: Выполняется проверка, подтверждающая отсутствие переменной с таким именем.
• Шаг №2: Если нет других переменных с таким же именем, создается переменная. Поскольку тип данных переменной не объявлен, VBA использует тип Variant по умолчанию и назначает один из его подтипов.

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

Как объяснил Джон Уокенбах в Excel 2013 Power Programming with VBA , символы объявления типа являются «пережитком» BASIC. Он согласен с тем, что вообще лучше объявлять переменные, используя описанные выше методы .

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

Например, в случае макросов Variable_Test и Variable_Test_Copy, показанных выше, можно присвоить тип данных Integer переменным Variable_One и Variable_Two, добавив символ объявления типа % в конце их соответствующих имен. Тогда код VBA выглядит следующим образом:

Как показано выше, вам нужно включить символ объявления типа только один раз . После этого вы можете использовать имя переменной как обычно (без символа объявления типа). На следующем рисунке показано, как это происходит в макросах Variable_Test и Variable_Test_Copy:

2 основных преимущества неявного объявления переменных, как описано выше :

• Преимущество №1: Больше гибкости: без объявления переменные, вы более гибки, поскольку всякий раз, когда вам нужна переменная, вы просто используете ее в операторе, чтобы объявить ее неявно.
• Преимущество №2: Вы пишете меньше кода VBA.

Однако, прежде чем вы решите объявить свои переменные неявно, как описано в этом разделе, помните о преимуществах постоянного объявления ваших переменных и использования оператора Option Explicit, а также о потенциальных проблемах, источником которых является отсутствие объявления переменных.

Заключение

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

В противном случае вы можете столкнуться с множеством проблем при отладке кода VBA. Или, что еще хуже, ваши макросы могут просто не работать должным образом (без вашего ведома) и возвращать неверные результаты.

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

• Что такое переменная VBA.
• Почему удобно объявлять переменные VBA явно.
• Как вы можете помнить о явном объявлении переменных.
• Как объявлять переменные VBA, принимая во внимание, среди прочего, желаемую область действия и срок службы этой переменной.
• Как назвать переменные.
• Как присвоить значения или выражения переменным VBA.

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

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

• Посмотрите, что подходит именно вам.
• Формализуйте это.
• Используйте его постоянно.

Книги, на которые есть ссылки в этом учебнике по Excel

• Walkenbach, John (2013). Excel 2013 Power Programming с помощью VBA . Хобокен, Нью-Джерси: John Wiley & Sons Inc.

Переменные (объявление, типы данных и область действия)

Домашняя страница ➜ VBA ➜ Переменные VBA (объявление, типы данных и область действия)

Переменная VBA

Типы данных

Типы данных объяснены

Явно или неявно

Статическая переменная

Именование переменной

. вашей системы, но она может хранить в ней значение для вас, и вы можете использовать это значение в своем коде и можете изменить это значение, если хотите (как следует из названия, «ПЕРЕМЕННАЯ» — это то, чье значение не является фиксированным).

Чтобы объявить переменную, вам нужно выполнить простую процедуру:

1. Используйте ключевое слово «Dim» в начале.
2. Укажите имя переменной.
3. Используйте ключевое слово «Как» после имени.
4. Укажите «Тип данных» для переменной в соответствии со значением, которое вы хотите ей присвоить.

Здесь мы использовали имя «startDate» и указали тип данных «Date». После объявления переменной вы можете присвоить ей значение.

 Dim startDate As Date
startDate = «10.11.2018» 

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

Полезные ссылки: Запуск макроса — Средство записи макросов — Редактор Visual Basic — Личная книга макросов или константа. Например, если вы хотите сохранить дату в переменной, вы должны в первую очередь объявить дату этой переменной как ее тип данных.

Описание типов данных

Ниже приведен полный список типов данных, которые можно использовать в VBA.

Data Type	Bytes Used	Range of Values ​​
Byte	1 byte	0 to 255
Boolean	2 bytes	True or False
Целое число	2 байта	от -32 768 до 32 767
Длинное (длинное целое)	4 байта	от -2 147 483 648 до 2 147 483 647
Одиночный	4 байта	от -3,402823E31 до -1,404 для отрицательных значений; от 1.401298E-45 до 3.402823E38 для положительных значений
Double	8 байт	-1. 79769313486231E308 до -4.94065645841247E-324 для отрицательных значений; От 4,94065645841247E-324 до 1,79769313486232E308 для положительных значений
Валюта	8 байт	-922,337,203,685,477.5808 to 922,337,203,685,477.5807
Decimal	14 bytes	+/-79,228,162,514,264,337,593,543,950,335 with no decimal point;+/-7.62514264337593543950335 with 28 places to the right of the decimal
Date	8 bytes	January 1, От 100 до 31 декабря 9999
Объект	4 байта	Любая ссылка на объект
Строка (переменной длины)	10 bytes + string length	0 to approximately 2 billion
String (fixed length)	Length of string	1 to approximately 65,400
Variant (with numbers)	16 bytes	Any числовое значение до диапазона Double
Вариант (с символами)	22 байта + длина строки	Тот же диапазон, что и для строки переменной длины
Определяется пользователем	Варьируется	Диапазон каждого элемента совпадает с диапазоном его типа данных

Настоятельно рекомендуется объявлять тип данных для переменных и констант.

Когда вы указываете тип данных для переменной или константы, это гарантирует правильность ваших данных и предотвращает ввод недопустимого типа данных. Если вы не укажете тип данных, VBA применит к вашей переменной тип данных Variant — он является наиболее гибким, и VBA не угадает, каким должен быть тип данных.

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

Явно или неявно

Вы можете объявить переменную явно или неявно. Явное объявление означает, что перед тем, как присвоить значение переменной, вы объявляете ее и определяете ее значение. ПРЕИМУЩЕСТВО этого заключается в том, что вы определяете его, и его тип данных VBA всегда хранит данные в этом формате.

Вот пример:

 Dim myDate As Date 

Поэтому, когда вы сохраняете значение в этом VBA, всегда будет применяться формат даты. Но с неявным объявлением вы не беспокоитесь об этом операторе явного объявления. Вместо этого вы определяете значение переменной и используете его в операторе кода. В неявном объявлении VBA хранит данные в переменной типа Variant, потому что вы не указали тип.

Другими словами, если вы просто используете переменную в своем коде, не объявляя ее, она является неявной. Ниже приведен пример неявного объявления:

 myDate = «10.11.1990» 

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

Статическая переменная

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

Чтобы сделать переменную статической, чтобы она сохраняла значение, вам просто нужно использовать ключевое слово «Static» вместо «Dim».

Присвоение имени переменной

Вы можете назвать переменную (эти правила также применимы к имени константы и процедуры) так, как вы хотите, но есть несколько правил, которым вы должны следовать:

• Вы можете использовать буквы, цифры и некоторые знаки пунктуации, но первым символом имени должен быть алфавит.
• Пробелы или точки не являются допустимыми символами для использования в имени, но вы можете использовать подчеркивание, чтобы сделать имя читабельным.
• В имени нельзя использовать специальные символы.
• Длина имени может составлять 254 символа, но использование имени не имеет смысла.
• Есть много зарезервированных слов, которые нельзя использовать для имени. Если вы попытаетесь использовать одно из этих слов, вы получите сообщение об ошибке.
• VBA не различает регистры.

Scope

На этом этапе вы знаете о процедурах и о том, какая процедура полезна в какой ситуации, вы также узнаете о переменных и о том, как определять их типы данных.

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

1. Уровень процедуры: Вы можете использовать переменную только в той процедуре, в которой вы ее объявили.
2. Уровень модуля (частный): Делает переменную доступной из всех процедур в модуле.
3. Уровень модуля (общедоступный): Делает переменную доступной из всех процедур во всех модулях.

Областью действия переменной по умолчанию является процедура (Procedure-Level), в которой объявлена ​​эта переменная.

Но позвольте мне поделиться с вами кое-чем из реального мира.

Я работаю в коворкинге, и место, где я сижу, находится на первом этаже трехэтажного здания В основном я сижу на одном и том же месте каждый день. Поэтому, если вы объявляете переменную с областью действия на уровне процедуры, вы можете использовать ее только в той же процедуре. Также как я каждый день сижу на одном и том же месте на одном и том же этаже. Но позвольте мне сказать вам больше: хотя я сижу на первом этаже, я могу использовать любое место и на других этажах. А на приведенном ниже снимке мы объявили переменную «myName» в верхней части модуля, используя ключевое слово Private перед запуском любой процедуры, и я использовал ее во всех трех кодах. Думайте об этом модуле как о здании, где у вас есть разные этажи (процедуры), и поскольку вы уже объявили переменную в начале модуля, вы можете использовать любую из процедур этого модуля. Это называется областью на уровне частного модуля. И вот последнее: у моего офиса есть филиалы в разных городах по всей стране, и если я поеду туда, я могу пойти в эти офисы и использовать любое из мест, если захочу. Поэтому, если у вас есть разные модули в вашей книге, вы можете использовать переменную во всех этих модулях, объявив ее общедоступной.

Есть еще

• Глобальная переменная в VBA
• Dim Statement
• Диапазон или ячейка как переменная
• Переменная в окне сообщения
• Option Explicit

Переменные VBA — объявление с использованием типов данных VBA Dim и VBA

В этом уроке мы узнаем о переменных VBA. Мы начнем с понимания оператора VBA Dim, необходимого для объявления переменной VBA. Далее мы углубимся в типы данных, доступные в Excel VBA. Мы продолжим углубляться в более сложные темы.

Объявление и определение переменной VBA

Сначала давайте начнем с простого примера использования переменной:

Dim myVar как целое число
моя переменная = 10
 

Так что же такое переменная? Это в основном символическое имя для места хранения, для хранения данных или указателей на данные. Без переменных вы могли бы обрабатывать любые данные. При использовании переменных необходимо выполнить 2 шага:

1. Объявить переменную – объявить символическое имя переменной (а иногда и тип данных)
2. Определить переменную – установить значение переменной

Давайте различать два шага:

Dim myVar As Integer 'Явное объявление с использованием оператора VBA Dim
myVar = 10 'Определение
 

VBA обычно (без макроса Option Explicit) позволяет просто определить новую переменную с любым явным объявлением. Это означает, что это одинаково верно:

myVar = 10 'Неявное объявление и определение
 

При объявлении переменных не забудьте поставить перед ними оператор Dim .

Объявление нескольких переменных
Вы также можете использовать оператор Dim для объявления нескольких переменных в одной строке с помощью оператора VBA Dim.

Dim myVar1 как Integer, myVar2 как String, someDate как Date
 

Типы данных

Ниже приведен список типов данных, доступных в VBA. Более подробный список см. здесь (MSDN).

Тип данных	байт	Диапазон значений
Логический	Зависит от реализации платформы	Верно или неверно
Байт	1 байт	от 0 до 255 (без знака)
Дата	8 байт	00:00:00 (полночь) 1 января 0001 г. до 23:59:59 31 декабря 9999
Double (двойная точность с плавающей запятой) 906:20	8 байт	от -1,79769313486231570E+308 до -4,94065645841246544E-324 † для отрицательных значений; от 4,94065645841246544E-324 до 1,79769313486231570E+308 † 2 для положительных значений 908
Целое число	4 байта	от -2 147 483 648 до 2 147 483 647 (подпись)
Длинное (длинное целое)	8 байт	-9 223 372 036 854 775 808 – 9 223 372 036 854 775 807 (9,2…E+18 †) (подпись) 906:20
Объект	4 байта на 32-битной платформе; 8 байт на 64-битной платформе	Любой тип может быть сохранен в переменной типа Object
Single (с плавающей запятой одинарной точности)	4 байта	от -3,4028235E+38 до -1,401298E-45 † для отрицательных значений; от 1,401298E-45 до 3,4028235E+38 † для положительных значений
Строка (переменной длины)	Зависит от реализации платформы 906:20	от 0 до примерно 2 миллиардов символов Unicode
Тип	переменная	Пользовательский тип данных, содержащий один или несколько элементов (переменных). Подробнее здесь. Не может содержать подпрограммы или функции, такие как тип данных класса, однако полезен в файлах двоичной записи/чтения.
Пользовательский (структура)	Зависит от реализации платформы	Каждый элемент структуры имеет диапазон, определяемый его типом данных и не зависящий от диапазонов других элементов 906:20

Option Explicit

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

мояПеременная = 10 'мояПеременная = 10
разрешение = myVa 'разрешение = 0
 

Как вы можете видеть выше, я определил переменную с именем myVar со значением 10. Во второй строке я определил новую переменную res со значением myVa — опечатка в имени моей переменная myVar . Теперь, когда myVa является новой переменной без определенного значения, VBA присвоит нулевое значение по умолчанию этой новой переменной, равной 0.

Чтобы предотвратить такие ошибки, используйте оператор Option Explicit в первой строке вашего модуля как показать ниже:

Опция явная
Подзапуск()
   myVar = 10 'ОШИБКА! myVar не определен!
Конец сабвуфера
 

Опция явная
Подзапуск()
   Dim myVar как целое число
   myVar = 10 'Хорошо!
Конец сабвуфера
 

Как видите, добавление оператора Option Explicit приведет к возникновению ошибки при использовании/определении переменной, которая ранее не была объявлена ​​ .

Константы

В VBA вы также можете объявлять константы — значения, которые могут быть определены только один раз и не могут быть изменены (вызовет исключение). Это пример объявления константы:

   Const myVar как целое число = 10
   Dim x как целое число
   x = myVar + 1 'Хорошо!
   myVar = 11 'ОШИБКА! Константы не могут быть переопределены
 

Частные и общедоступные переменные VBA

Частная переменная VBA

Переменная, которая недоступна только в той области, в которой она была объявлена. Ниже приведены некоторые примеры частных переменных. В VBA дополнительно переменные Prviate могут быть объявлены во ВСЕХ областях, кроме Subs и Functions (вместо этого используйте оператор Dim, который эквивалентен).

Частный var как строка
Подпрограмма SomeSub()
  'var является приватным в этом модуле
  var = "Привет!"
  'Эти переменные также являются частными в рамках Sub
  Dim subVar как строка
  subVar = "Привет!"
Конец сабвуфера

СубтестSub()
   SomeSub

   'Покажет сообщение "Привет!"
   MsgBox переменная
  'Покажет пустой MsgBox, так как subVar недоступна в этой области
   Подпеременная MsgBox
Конец сабвуфера
 

Общедоступная переменная VBA

Переменная, доступная во ВСЕХ областях, в отличие от частных переменных. Ниже приведены некоторые примеры открытых переменных. В VBA дополнительно общедоступные переменные могут быть объявлены во ВСЕХ областях, кроме подпрограмм и функций.

'---Модуль 1---
Общедоступная переменная как строка
Подпрограмма SomeSub()
  'var является общедоступным в этом модуле
  var = "Привет!"
Конец сабвуфера

'---Модуль 2---
СубтестSub()
   SomeSub

   'Покажет сообщение "Привет!"
   MsgBox переменная
Конец сабвуфера
 

Глобальные переменные VBA

Глобальные переменные в основном эквивалентны общедоступным переменным. Разница в том, что глобальные переменные можно использовать только в модулях, тогда как общедоступные можно использовать во всех контекстах/областях, например. модули, классы, формы и т. д.
Глобальные переменные, скорее всего, сохранены для обратной совместимости (более старые версии Excel), поэтому я рекомендую вам использовать только общедоступные переменные.

Узнайте, как объявлять переменные в VBA [шаг за шагом]

 Sub getNames()
Dim firstName As String

End Sub 

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

Итак, в нашем случае мы говорим: «Я буду использовать переменную с именем firstName, и она будет содержать строки».

Наконец, у нас есть «End Sub», который сообщает Excel, что мы закончили работу над этой процедурой.

Установка переменных

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

В VBA объявление переменных необязательно, но вы не можете одновременно объявлять И устанавливать переменную.

Вместо этого вам нужно создать новую строку, которая присваивает значение . Давайте рассмотрим пример:

 Sub getNames()
 Dim firstName As String
 firstName.Value = "Джейсон"
Конец суб 

Мы добавили строку, которая присваивает значение переменной. В VBA просто добавьте «.Value», знак равенства и значение, которое вы хотите присвоить (в кавычках).

Вот еще один пример другого объявления VBA:

 Sub calculateSales()
 Тусклое среднееПродажи до тех пор, пока
 среднееПродажи.Значение = "43000"
End Sub 

В этом примере мы сообщаем Excel, что AverageSales будет содержать числа, потому что тип данных Long предназначен для хранения больших чисел. Кроме того, переменная mediumSales должна иметь начальное значение 43 000.

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

Каспер Лангманн , соучредитель Spreadsheeto

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

 mediumSales = "43000" 

Однако, как правило, при программировании рекомендуется быть как можно более конкретным. А поскольку ввести «.Value» легко, нет причин не делать этого.

Общие типы данных в VBA

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

Это базовое введение в типы данных. Для большинства новичков в VBA это будет все, что вам нужно знать. Однако, если вам нужна дополнительная информация, например, количество байтов или определяемые пользователем структуры, ознакомьтесь со сводкой типов данных Microsoft.

Каспер Лангманн , соучредитель Spreadsheeto

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

Целое число  может содержать 2 байта данных. Это означает, что он может содержать целые числа от -32 768 до 32 767.

Long  может содержать 4 байта. Это от -2 147 483 648 до 2 147 483 647

Double содержит 8 байтов, но включает десятичные дроби!

Стоит отметить, что тип данных double хранит только приблизительные значения длинных чисел. Это делает его удобным для хранения очень больших чисел, но может вызвать некоторые проблемы со сложными вычислениями.

Каспер Лангманн , соучредитель Spreadsheeto

Имейте в виду, что Integer всегда будет округлять десятичные дроби до ближайшего целого, а это означает, что вы можете получить странные результаты, если не ожидаете этого. Если вам нужна большая точность, используйте Double.

Существует много других типов числовых данных . Но вы должны быть в состоянии справиться практически с любым случаем с 3 выше.

Как насчет нечисловых типов? Есть два общих: Строка и Булево значение .

Строка проста — она содержит текст. Excel не сможет выполнять вычисления со строками (хотя и сможет использовать некоторые текстовые функции).

Логическое значение содержит значения true и false; вы можете использовать 0 или 1 в числовом типе данных, но вы можете сэкономить вычислительную мощность и быть более точными в своих назначениях данных, если вы используете логическое значение.

Привыкайте к работе с переменными

Если вы планируете использовать VBA для создания макросов, вам понадобится  привыкнуть к работе с переменными . Вы будете использовать их много.

Пока не беспокойтесь о типах данных. Если вы знаете, что Integer округляет до целых чисел, а Double — и для больших чисел, и для точности, вы сделали хорошее начало.

Опять же, если вы хотите увидеть различные типы данных, поддерживаемые VBA, и какие данные они могут хранить, посетите справочную страницу Microsoft по типам данных.

Каспер Лангманн2020-05-11T13:36:18+00:00 Ссылка на загрузку страницы

Объявление переменной VBA | Как использовать объявление переменной в Excel VBA

Хотя не обязательно объявлять переменную на самом первом этапе кодирования VBA. Мы можем сдвинуть или переместить этот процесс позже между кодом, прежде чем вызывать значения, хранящиеся в этой переменной. Но всегда желательно объявлять в начале кода. Итак, у нас будет идея, каким и всем переменным нужно присвоить какое-либо значение.

В VBA у нас есть 2 типа данных. Фиксированные и переменные. Переменные — это те типы данных, значения которых всегда будут меняться и могут быть изменены. Переменные в VBA — это те типы данных, которые состоят из некоторого значения или памяти. Все, что мы вводим в переменную, сохраняется где-то в памяти переменных.

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

Существует несколько часто используемых типов данных для объявления любых переменных:

• Целые числа
• Строка
• Двойной
• Длинный и т. д.

Как использовать объявление переменной Excel VBA?

Теперь давайте попробуем с некоторыми примерами объявления переменных VBA в Excel.

Вы можете скачать этот шаблон объявления переменной VBA в Excel здесь — Шаблон объявления переменной VBA в Excel

Пример № 1 — объявление переменной VBA

В этом примере мы увидим, как использовать переменную с типом данных Integer. Для этого нам понадобится модуль, в котором мы будем писать код.

Шаг 1: Итак, перейдите в меню Вставить и выберите Модуль , как показано ниже.

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

Код:

 Sub VBA_Variable()

End Sub 

Шаг 3: Здесь мы будем печатать числа возраста. Таким образом, определите любую переменную, например Age , с типом данных 9.0015 Целое число , как показано ниже.

Код:

 Sub VBA_Variable()

Dim Age как целое число

End Sub 

Шаг 4: Целое число может хранить значение в диапазоне от -32768 до +32767 ок. Теперь присвойте значение объявленной переменной Age , допустим, это 10.

Код:

 Sub VBA_Variable()

Dim Age как целое число
Возраст = 10

Концевой переходник 

Шаг 5: Теперь, чтобы увидеть значение, хранящееся в переменной Age , мы будем использовать MsgBox , как показано ниже. Это напечатает значение, хранящееся в любой назначенной переменной.

Код:

 Sub VBA_Variable()

Dim Age как целое число
Возраст = 10
MsgBox Возраст

End Sub 

Шаг 6: Теперь, наконец, скомпилируйте код и запустите его, нажав кнопку  Play , которая находится под строкой меню, или нажмите 9.0015 F5 функциональная клавиша. Мы увидим окно сообщения, содержащее номер Возраста как 10 , который находится под диапазоном целочисленного предела.

Пример №2.

Объявление переменной VBA

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

Шаг 1: Сначала откройте модуль и напишите там подкатегорию, как показано ниже.

Код:

 Sub VBA_Variable2()

End Sub 

Шаг 2: Теперь определите переменную как Name и присвойте ей тип данных String , как показано ниже.

Код:

 Sub VBA_Variable2()

Dim Name As String

End Sub 

Шаг 3: Затем в определенной переменной Name присвойте ей любое текстовое значение. Допустим, это значение « VBA Macro », как показано ниже.

Код:

 Sub VBA_Variable2()

Dim Name As String
Имя = "Макрос VBA"

End Sub 

Шаг 4: Чтобы получить значение, хранящееся в имени переменной, мы будем использовать msgbox для вывода значения, как показано ниже.

Код:

 Sub VBA_Variable2()

Dim Name As String
Имя = "Макрос VBA"
Имя почтового ящика

End Sub 

Шаг 5: Теперь скомпилируйте код и запустите. Мы увидим, что в окне сообщения напечатано «Макрос VBA».

Шаг 6: Так же вместо MsgBox выберем еще и диапазон ячеек, куда нужно вывести значение. Для этого выберите функцию «Диапазон», чтобы назначить ячейки местоположения, в которых мы хотим напечатать значения, хранящиеся в определенной переменной. Давайте рассмотрим эти ячейки от A1 до D3, а затем поместим значение, хранящееся в переменной, как показано ниже.

Код:

 Подпрограмма VBA_Variable3()

Dim Name As String
Имя = "Макрос VBA"
Диапазон ("A1: D3") = "Макрос VBA"

End Sub 

Шаг 7: Теперь снова запустите код. Мы увидим, что текст «Макрос VBA» будет напечатан из ячейки A1 в D3, как показано ниже. Пример № 3. Объявление переменной VBA0057). Предположим, мы хотим сохранить значение памяти, которое больше, чем может позволить целое число. Для этого

Шаг 1:  Откройте новый модуль и создайте подкатегорию. И определите переменную как Memory , назначьте ей тип данных Long , как показано ниже.

Код:

 Sub VBA_Variable4()

Тусклая память

End Sub 

Шаг 2: Теперь назначьте любое большое значение, скажем, 123123, которое находится за пределами диапазона Integer, как показано ниже.

Код:

 Sub VBA_Variable4()

Тусклая память
Память = 123123

End Sub 

Шаг 3: Теперь используйте MsgBox для печати значения, хранящегося в переменной памяти, как показано ниже, с единицей памяти как « байт »

Код:

 Sub4 VBA_Variable()

Тусклая память
Память = 123123
Память MsgBox и «байты»

Концевой переходник 

Шаг 4: Теперь запустите код. Мы получим окно сообщения с сообщением «123123 байта» в качестве значения, хранящегося в переменной Memory .

Плюсы объявления переменных VBA

• Переменная определяет тип переменной, которую мы хотим объявить.
• Если мы объявим какую-либо переменную в начале кода, то это напоминание о том, что мы будем рассматривать возможность сохранения в ней значений.
• Мы можем хранить значения любого типа в переменных, но тип данных должен быть именно таким.

Что следует помнить

• Существует ограничение на запись имени переменной, которое не должно превышать 255
• Всегда объявляйте переменную в начале кода.
• Переменные не чувствительны к регистру, но между именами переменных не должно быть пробелов.
• Не должно содержать никаких специальных символов.
• Переменная должна начинаться с текста или алфавита, а не с любого числа.
• После создания макроса сохраните файл как Macro enable excel, чтобы не потерять код.