Что такое public в excel - Word и Excel - помощь в работе с программами

Глобальная переменная в проекте VBA Excel. Объявление глобальной переменной в модуле проекта VBA и обращение к ней из других модулей того же проекта.

Объявление глобальной переменной

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

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

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

Пример объявления глобальных переменных в любом модуле проекта VBA:

Public myGlobVar1 ‘по умолчанию — As Variant

Public myGlobVar2 As String

Public myGlobVar3 As Double

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

Обращение к глобальной переменной

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

Переменная в стандартном модуле

Если глобальная переменная (myGlobVar) объявлена в стандартном модуле (Module1) с уникальным именем, не повторяющимся в других модулях, к ней можно обращаться из других модулей по одному имени (в примере — из модуля формы):

Private Sub CommandButton1_Click()

myGlobVar = «Глобальная переменная»

TextBox1.Text = myGlobVar

End Sub

Стандартное обращение с указанием имени модуля (Module1), в котором объявлена глобальная переменная (myGlobVar):

Private Sub CommandButton1_Click()

Module1.myGlobVar = «Глобальная переменная»

TextBox1.Text = Module1.myGlobVar

End Sub

Переменная в модуле книги

Глобальная переменная (myGlobVar), объявленная в модуле книги, доступна при обращении к ней из других модулей с помощью следующего кода VBA Excel:

Sub Primer1()

ThisWorkbook.myGlobVar = «Глобальная переменная»

MsgBox ThisWorkbook.myGlobVar

End Sub

Переменная в модуле листа

Обращение к глобальной переменной (myGlobVar), объявленной в модуле рабочего листа (Лист1), из других модулей по имени листа (в проводнике проекта находится без скобок слева от имени ярлыка):

Sub Primer2()

Лист1.myGlobVar = «Глобальная переменная»

MsgBox Лист1.myGlobVar

End Sub

По имени ярлыка (в проводнике проекта находится в полукруглых скобках справа от имени листа):

Sub Primer3()

Worksheets(«Лист1»).myGlobVar = «Глобальная переменная»

MsgBox Worksheets(«Лист1»).myGlobVar

End Sub

Переменная в модуле формы

Глобальная переменная (myGlobVar), объявленная в модуле формы (UserForm1), доступна при обращении к ней из других модулей с помощью следующего кода VBA Excel:

Sub Primer4()

UserForm1.myGlobVar = «Глобальная переменная»

MsgBox UserForm1.myGlobVar

End Sub

Переменная в личной книге макросов

Обращение к глобальной переменной (myGlobVar), объявленной в модуле ЭтаКнига проекта VBAProject (PERSONAL.XLSB) из модуля проекта VBA обычной книги Excel:

Sub Primer5()

Workbooks(«PERSONAL.XLSB»).myGlobVar = «Глобальная переменная»

MsgBox Workbooks(«PERSONAL.XLSB»).myGlobVar

End Sub

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

Источник

Хитрости »

1 Май 2011 225742 просмотров

Что такое переменная и как правильно её объявить?

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

Для чего нужна переменная? Чтобы хранить значение и применить его позже в любой момент. Например, в ячейке А1 записана сумма, а нажатием на кнопку запускается обновление отчета. После обновления отчета сумма в А1 изменится. Необходимо сверить сумму до обновления с суммой после и в зависимости от этого сделать какое-либо действие. Переменная как раз позволит запомнить значение ячейки до того, как она обновится и использовать именно это значение после обновления.

Требования к переменным
Типы данных, хранимых в переменных
Как объявлять переменные
Как правильно назвать переменную
Пример использования переменных
Константы

В качестве имен переменных можно использовать символы букв и числа, но первой в имени переменной всегда должна быть буква. Не допускается использование точки, запятой, пробела и иных знаков препинания, кроме нижнего подчеркивания. Длина имени не должна превышать 254 символов. Так же нельзя использовать в качестве имен для переменных зарезервированные константы редактора VBA(например Sub, Msgbox, ubound, Date и т.п.). Так же для переменных неважен регистр букв.

Теперь рассмотрим основные декларированные в VBA

типы данных, которые можно хранить в переменных:

Тип данных	Занимает байт в памяти	Пределы значений
Byte	1	Целые числа от 0 до 255
Boolean	2	True или False
Integer	2	Целые числа от (-32768) до 32767
Long	4	Целые числа от (-2147483648) до 2147483647
Single	4	От (–3.402823Е+38) до (–1.401298Е-45) и от 1.401298Е-45 до 3.402823Е+38
Double	8	От ±1.79769313486232Е+308 до ±4.94065645841247Е-324
Decimal	12	От ±79228162514264337593543950335 без десятичных знаков до ±7,9228162514264337593543950335 с 28-ю знаками после запятой
Currency	8	От (–922337203685477.5808) до 922337203685477.5807
Date	8	От 01.01.100 до 31.12.9999(не надо путать с датами в Excel — 01.01.1900 до 31.12.9999)
String	10(+длина строки)	От 0 до 65400 символов для фиксированных строк и чуть более 2 млрд. для строк переменной длины
Object	4	Любой объект
Array	Определяется кол-вом и размером элементов	—
Variant	от 16-ти	Любой из встроенных типов данных

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

Тип данных Decimal больше не используется, поэтому объявить переменную данного типа в VBA не получится — подобная попытка приведет к синтаксической ошибке. Для работы с данными типа Decimal переменную необходимо изначально объявить как Variant или вообще без типа (например Dim a), т.к. тип данных Variant используется в VBA по умолчанию и принимает любой тип данных.

Так же переменным можно назначать и другие типы данных, которых нет в таблице выше — это типы, которые поддерживаются объектной моделью приложений, к которым «подключен» VBA. Например, если зайти в VBA из Excel, то библиотека типов объектной модели Excel подключена по умолчанию и для переменных становится доступно множество типов этой объектной модели. Многие из них знакомы всем: Workbook, Worksheet, Range, Cells, Chart и т.д. Т.е. это книги, листы, ячейки, диаграммы. Типов много, почти на каждый объект и коллекцию. Рассматривать здесь все бессмысленно. Могу лишь привести пару строк кода:

Dim rRange as Range 'назначили переменной тип ячейка/диапазон
Set rRange = Range("A1") 'присвоили ссылку на ячейку A1 текущего листа

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

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

На самом деле все очень просто. Это делается при помощи операторов области действия: Dim, Public,Static и оператора присвоения типа As. Самый распространенный оператор — Dim. Его и возьмем в качестве примера. Синтаксис объявления:

[оператор области действия] Имя_переменной As [тип данных]

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

Dim MyVar1, MyVar2, MyVar3 As Integer

Вроде бы исходя из логики всем переменным присвоен тип данных Integer. Но это ошибочное суждение. Тип Integer присвоен только последней переменной, к которой он «привязан» оператором As — MyVar3. Все остальные переменные имеют тип данных Variant. Т.е. если Вы не задаете каждой переменной свой тип хранимых данных явно(т.е. не указываете для неё тип данных через As), то VBA сам присваивает для такой переменной тип данных Variant, т.к. он может хранить любой тип данных. А вот так выглядит правильное присвоение типа данных:

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

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

Dim MyVar1%, MyVar2%, MyVar3%

Всего шесть типов, которые можно объявить подобным методом:
! — 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 еще потерпит такие имена, а вот более крупные проекты — не советовал бы я в них оперировать такими переменными. Вы сами запутаетесь какая переменная как объявлена и какой тип данных может хранить и что за значение ей присвоено. Поэтому лучше всего давать переменным осмысленные имена и следовать соглашению об именовании переменных. Что за соглашение? Все очень просто: перед основным названием переменной ставится префикс, указывающий на тип данных, который мы предполагаем хранить в данной переменной. Про имеющиеся типы данных я уже рассказал выше. А ниже приведена примерная таблица соответствий префиксов типам данных:

Префикс	Тип хранимых данных
b	Boolean
bt	Byte
i	Integer
l	Long
s	Single
d	Double
c	Currency
dt	Date
str	String
obj	Object
v	Variant

Лично я немного для себя её переделал, т.к. некоторые обозначения мне кажутся скудными. Например Double я обозначаю как dbl, а Single как sgl. Это мне кажется более наглядным.

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

DefBool B
Sub test()
    Dim bCheck
End Sub

Автоматически переменной bCheck будет присвоен тип Boolean, т.к. она начинается с буквы b — регистр здесь не имеет значения(впрочем как в VBA в целом). Оператор Def задается в области объявления. Можно задать не одну букву, а целый диапазон букв:

DefBool B-C
Sub test()
    Dim bCheck, cCheck
End Sub

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

DefBool B
DefStr S
Sub test()
    Dim bCheck, sCheck
End Sub

Ниже приведен полный перечень операторов типов и данные, которые задает каждый из них:
DefBool — Задает тип Boolean
DefByte — Задает тип Byte
DefCur — Задает тип Currency
DefDate — Задает тип Date
DefDbl — Задает тип Double
DefInt — Задает тип Integer
DefLng — Задает тип Long
DefObj — Задает тип Object
DefSng — Задает тип Single
DefStr — Задает тип String
DefVar — Задает тип Variant
По умолчанию в VBA применена инструкция DefVar для всех букв(иначе говоря для всех переменных, которым не назначен тип данных явно через оператор 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

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

Видеоуроки

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

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

Источник

Открытая переменная Excel VBA

Открытая переменная Excel VBA

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

Переменная VBA считается общедоступной переменной в двух случаях. Когда —

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

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

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

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

В этом коде var1 — это переменная, определенная в подпроцедуре Ex_Var .

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

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

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

Как объявить публичные переменные в VBA?

Давайте рассмотрим несколько примеров объявления открытых переменных в VBA.

Вы можете скачать этот шаблон VBA Public Variables Excel здесь — Шаблон VBA Public Variables Excel

Пример № 1 — Публичное определение переменной в модуле

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

Шаг 1. Откройте редактор Visual Basic (VBE), нажав Alt + F11 или нажав кнопку Visual Basic на вкладке Разработчики в Excel. Выберите вкладку «Вставка», перейдите к «Модули» и нажмите на нее. Он добавит новый модуль в VBE для работы.

Шаг 2: В только что созданном модуле добавьте команду Option Explicit в начале кода VBA (перед созданием любой переменной). Опция Explicit помогает вам, если есть какая-либо опечатка при использовании определенной переменной. Если используемая переменная не определена в системе, эта опция выдает сообщение об ошибке о том, что переменная не определена.

Код:

 Вариант Явный

Шаг 3: Используйте оператор Dim для создания новой переменной с именем my_name с типом данных как String.

Код:

 Опция Явный Dim my_name As String

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

Предположим, что код приведен ниже, я присвоил значение переменной my_name как «Lalit Salunkhe».

Код:

 Параметр Явный Dim my_name As String Sub Ex_1 () my_name = "Lalit Salunkhe" MsgBox "Меня зовут:" & my_name End Sub

Если я выполню этот код, я увижу окно сообщения, как показано на скриншоте ниже:

Мы также можем использовать эту переменную в разных подпроцессах в одном и том же модуле. Смотрите скриншот, приведенный ниже:

Код:

 Опция Явное Dim my_name As String Sub Ex_1 () my_name = "Lalit Salunkhe" MsgBox "Меня зовут:" & my_name End Sub Sub Ex_2 () Dim my_age As Integer my_name = "Lalit Salunkhe" my_age = 28 MsgBox "Меня зовут: "& my_name &"; Мой возраст: "& my_age End Sub

Смотрите подпроцесс Ex_2. У него есть новая переменная, определенная my_age. Я использовал my_name, чтобы добавить свое имя, и my_age, чтобы добавить мой возраст. Вы можете видеть, что my_name все еще доступно во второй подпроцедуре. После запуска этого кода мы можем получить вывод в виде окна сообщения, показанного ниже:

Вот как мы можем определить переменную публично в модуле.

Пример № 2 — Определение переменной публично для всех модулей

Чтобы достичь этого навыка, вам нужно использовать ключевые слова как Public или Global вместо Dim, который устанавливает переменную как public для всех модулей, где бы вы ни работали.

Шаг 1: Создайте новый модуль. Перейдите на вкладку « Вставка », нажмите « Модуль», чтобы добавить новый модуль в VBE.

Шаг 2: Добавить опцию Явный в модуле.

Код:

 Вариант Явный

Шаг 3: Определите новую переменную с именем var1 и var2 как целое число типа. Но на этот раз мы используем Public вместо Dim (который мы использовали ранее).

Код:

 Опция Явный Public var1 As Integer Public Var2 As Integer

Шаг 4: Теперь эти две переменные можно использовать в нескольких модулях, если они созданы в одном VBE. Смотрите пример, приведенный ниже:

Код:

 Опция Явный Public var1 As Integer Public var2 As Integer Sub Ex_3 () var1 = 10 var2 = 100 MsgBox "Значение для var1 равно:" & var1 & Chr (13) & "Значение для var2 равно:" & var2 End Sub

Мы присвоили значения обеим переменным, используя функцию MsgBox, пытаясь отобразить значения для этих двух переменных.

Шаг 5: Запустите код, нажав клавишу F5 или нажав кнопку Play, вы можете увидеть результат, как показано ниже:

Шаг 6: Мы будем использовать те же переменные в модуле Module1, которые мы использовали в первом примере, и попытаемся выяснить, доступны ли переменные там или нет.

Код:

 Опция Явное Dim my_name As String Sub Ex_1 () my_name = "Lalit Salunkhe" MsgBox "Меня зовут:" & my_name End Sub Sub Ex_2 () Dim my_age As Integer my_name = "Lalit Salunkhe" my_age = 28 MsgBox "Меня зовут: "& my_name &"; Мой возраст: "& my_age End Sub Sub Ex_public () var1 = 1000 var2 = 999 MsgBox" Значение для var1 равно: "& var1 & Chr (13) &" Значение для var2 равно: "& var2 End Sub

Если вы могли видеть скриншот выше, мы использовали тот же набор переменных, определенных в Module2, и имели значения, такие как 1000 и 999 соответственно. Мы используем функцию MsgBox для представления значений этих двух переменных соответственно. Запустите код, и вы увидите результат, как показано ниже:

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

То, что нужно запомнить

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

Общие сведения об области и видимости

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

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

Область на уровне процедуры

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

Область на уровне частного модуля

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

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

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

Область на уровне общедоступного модуля

Если переменная уровня модуля объявлена как общая (Public), то она доступна для всех процедур в проекте. В следующем примере строковая переменная может использоваться любой процедурой в любом модуле проекта.

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

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

Открытые процедуры, переменные и константы, определенные не в стандартных модулях или модулях класса, таких как модули формы или модули отчетов, недоступны для ссылок на проекты, так как эти модули являются частными для проекта, в котором они находятся.

См. также

Поддержка и обратная связь

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

Источник

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

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

В примере ниже создается переменная и указывается тип данных «String».

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

Чтобы предоставить доступ к переменной всем процедурам проекта, перед ней нужно поставить оператор Public, как показано в примере ниже:

Дополнительные сведения об именовании переменных см. в статье Правила именования в Visual Basic.

Переменные могут быть объявлены одним из следующих типов данных: Boolean, Byte, Integer, Long, Currency, Single, Double, Date, String (для строк переменной длины), String * length (для строк фиксированной длины), Object или Variant. Если тип данных не указан, по умолчанию присваивается тип данных Variant. Вы также можете создать определяемый пользователем тип с помощью оператора Type.

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

В приведенном ниже операторе переменные intX , intY и intZ объявлены типом Integer.

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

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

Сокращение для объявления переменных x и y типом Integer в приведенном выше операторе

Сокращение для типов: % -integer; & -long; @ -currency; # -double; ! – Single; $ – String

Оператор Public

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

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

Оператор Private

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

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

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

Оператор Static

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

Оператор Option Explicit

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

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

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

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

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

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

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

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

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

В документации приложения предоставлена информация о поддерживаемом им синтаксисе.

См. также

Поддержка и обратная связь

Источник

Understanding scope and visibility

Scope refers to the availability of a variable, constant, or procedure for use by another procedure. There are three scoping levels: procedure-level, private module-level, and public module-level.

You determine the scope of a variable when you declare it. It’s a good idea to declare all variables explicitly to avoid naming-conflict errors between variables with different scopes.

Procedure-level scope

A variable or constant defined within a procedure is not visible outside that procedure. Only the procedure that contains the variable declaration can use it. In the following example, the first procedure displays a message box that contains a string. The second procedure displays a blank message box because the variable is local to the first procedure.

Private module-level scope

You can define module-level variables and constants in the Declarations section of a module. Module-level variables can be either public or private. Public variables are available to all procedures in all modules in a project; private variables are available only to procedures in that module. By default, variables declared with the Dim statement in the Declarations section are scoped as private. However, by preceding the variable with the Private keyword, the scope is obvious in your code.

In the following example, the string variable strMsg is available to any procedures defined in the module. When the second procedure is called, it displays the contents of the string variable strMsg in a dialog box.

Public procedures in a standard module or class module are available to any referencing project. To limit the scope of all procedures in a module to the current project, add an Option Private Module statement to the Declarations section of the module. Public variables and procedures will still be available to other procedures in the current project, but not to referencing projects.

Public module-level scope

If you declare a module-level variable as public, it’s available to all procedures in the project. In the following example, the string variable can be used by any procedure in any module in the project.

All procedures are public by default, except for event procedures. When Visual Basic creates an event procedure, the Private keyword is automatically inserted before the procedure declaration. For all other procedures, you must explicitly declare the procedure with the Private keyword if you don’t want it to be public.

Use public procedures, variables, and constants defined in standard modules or class modules from referencing projects. However, you must first set a reference to the project in which they are defined.

Public procedures, variables, and constants defined in other than standard or class modules, such as form modules or report modules, are not available to referencing projects, because these modules are private to the project in which they reside.

Declaring variables

When declaring variables, you usually use a Dim statement. A declaration statement can be placed within a procedure to create a procedure-level variable. Or it may be placed at the top of a module, in the Declarations section, to create a module-level variable.

The following example creates the variable and specifies the String data type.

If this statement appears within a procedure, the variable strName can be used only in that procedure. If the statement appears in the Declarations section of the module, the variable strName is available to all procedures within the module, but not to procedures in other modules in the project.

To make this variable available to all procedures in the project, precede it with the Public statement, as in the following example:

For information about naming your variables, see Visual Basic naming rules.

Variables can be declared as one of the following data types: Boolean, Byte, Integer, Long, Currency, Single, Double, Date, String (for variable-length strings), String * length (for fixed-length strings), Object, or Variant. If you don’t specify a data type, the Variant data type is assigned by default. You can also create a user-defined type by using the Type statement.

You can declare several variables in one statement. To specify a data type, you must include the data type for each variable.

In the following statement, the variables intX , intY , and intZ are declared as type Integer.

In the following statement, intX and intY are declared as type Variant, and only intZ is declared as type Integer.

You don’t have to supply the variable’s data type in the declaration statement. If you omit the data type, the variable will be of type Variant.

The shorthand to declare x and y as Integer in the statement above is:

The shorthand for the types is: % -integer; & -long; @ -currency; # -double; ! -single; $ -string

Public statement

Use the Public statement to declare public module-level variables.

Public variables can be used in any procedures in the project. If a public variable is declared in a standard module or a class module, it can also be used in any projects that reference the project where the public variable is declared.

Private statement

Use the Private statement to declare private module-level variables.

Private variables can be used only by procedures in the same module.

When used at the module level, the Dim statement is equivalent to the Private statement. You might want to use the Private statement to make your code easier to read and interpret.

Static statement

When you use the Static statement instead of a Dim statement to declare a variable in a procedure, the declared variable will retain its value between calls to that procedure.

Option Explicit statement

You can implicitly declare a variable in Visual Basic simply by using it in an assignment statement. All variables that are implicitly declared are of type Variant. Variables of type Variant require more memory resources than most other variables. Your application will be more efficient if you declare variables explicitly and with a specific data type. Explicitly declaring all variables reduces the incidence of naming-conflict errors and spelling mistakes.

If you don’t want Visual Basic to make implicit declarations, you can place the Option Explicit statement in a module before any procedures. This statement requires you to explicitly declare all variables within the module. If a module includes the Option Explicit statement, a compile-time error will occur when Visual Basic encounters a variable name that has not been previously declared, or that has been spelled incorrectly.

You can set an option in your Visual Basic programming environment to automatically include the Option Explicit statement in all new modules. See your application’s documentation for help on how to change Visual Basic environment options. Note that this option does not change existing code that you have written.

You must explicitly declare fixed arrays and dynamic arrays.

Declaring an object variable for automation

When you use one application to control another application’s objects, you should set a reference to the other application’s type library. After you set a reference, you can declare object variables according to their most specific type. For example, if you are in Microsoft Word when you set a reference to the Microsoft Excel type library, you can declare a variable of type Worksheet from within Word to represent an Excel Worksheet object.

If you are using another application to control Microsoft Access objects, in most cases, you can declare object variables according to their most specific type. You can also use the New keyword to create a new instance of an object automatically. However, you may have to indicate that it is a Microsoft Access object. For example, when you declare an object variable to represent an Access form from within Visual Basic, you must distinguish the Access Form object from a Visual Basic Form object. Include the name of the type library in the variable declaration, as in the following example:

Some applications don’t recognize individual Access object types. Even if you set a reference to the Access type library from these applications, you must declare all Access object variables as type Object. Nor can you use the New keyword to create a new instance of the object.

The following example shows how to declare a variable to represent an instance of the Access Application object from an application that doesn’t recognize Access object types. The application then creates an instance of the Application object.

To determine which syntax an application supports, see the application’s documentation.

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

Рассмотрим такой пример: надо объявить три переменные разного типа, например, Byte, String и Long, это может выглядеть так:

dim A as Byte, B as String, C as Long

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

Тут A и В будут типа Variant и только C – Long. Что бы все правильно сработало, нам нужно каждой переменной назначить заданный тип:

dim A as Long, B as Long, C as Long

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

Если переменная VBA объявлена в начале модуля, то она сохраняется в памяти до тех пор, пока работает макрос, если объявление происходит в теле процедуры, то переменная будет удалена из памяти сразу, после выполнения блока кода заданной процедуры. Добавьте в редакторе Visual Basic новую форму и модуль.

Параметры формы: разместите на форме три компонента Label и три кнопки, как показано на рисунке. Имя формы (свойство Name) – VariableForm, имя модуля – VariableModule.

В редакторе кода для модуля пропишите:

Sub VariableModule()
    VariableForm.Show
End Sub

Тут мы просто определяем, что при запуске макроса нужно запустить форму.

В редакторе кода для формы пропишите:

'**************************************************
' Объявление локальных и глобальных переменных в VBA
'**************************************************
 
' Включаем проверку переменных VBA
Option Explicit
 
' Глобальная переменная
Dim GVar As Integer
'Нельзя присвоить значение вне процедуры!!!
'GVar = 10
Sub GetGlobal()
    ' Увеличиваем значение на 5
    GVar = GVar + 5
    Label1.Caption = "Глобальное значение " & GVar
End Sub
Sub GetLocal_1()
Dim LVar As Integer
    ' Увеличиваем значение на 2
    LVar = LVar + 2
    Label2.Caption = "Локальное значение " & LVar
End Sub
Sub GetLocal_2()
Dim LVar As Integer
    ' Увеличиваем значение на 3
    LVar = LVar + 3
    Label3.Caption = "Локальное значение " & LVar
End Sub
 
Private Sub CommandButton1_Click()
    Call GetGlobal
End Sub
 
Private Sub CommandButton2_Click()
    Call GetLocal_1
End Sub
 
Private Sub CommandButton3_Click()
    Call GetLocal_2
End Sub
 
Private Sub UserForm_Click()
 
End Sub
 
Private Sub UserForm_Initialize()
    ' настройка первого текстового поля
    Label1.FontSize = 12
    Label1.ForeColor = &HFF0000
    Call GetGlobal
 
    ' настройка второго текстового поля
    Label2.FontSize = 12
    Label2.ForeColor = &H6400
    Call GetLocal_1
 
    ' настройка третьего текстового поля
    Label3.FontSize = 12
    Label3.ForeColor = &HFF
    Call GetLocal_2
End Sub

В самом начале мы объявляем глобальную переменную VBA – GVar типа Integer, в комментарии указано, что вне процедуры присвоить значение переменной нельзя. Далее следуют три процедуры, в первой процедуре происходит увеличение значение глобальной GVar на 5, результат будет записываться в свойство Caption первого компонента Label. Вторя и третья процедуры производят аналогичные действия, только для объявленных в них локальных переменных VBA, LVar, происходит увеличение значения на 2 и на 3, соответственно. События Click (нажатие кнопки мыши) для кнопок будет вызывать заданные процедуры.

При запуске макроса в полях будут отображаться значения 5, 2 и 3. При нажатии на “Кнопка 1” будет происходить вызов процедуры GetGlobal и увеличение значения переменной GVar на 5. Для “Кнопка 2” и “Кнопка 3” будут вызываться процедуры GetLocal_1 и GetLocal_2, однако ничего увеличиваться не будет, так как переменные LVar являются локальными и при каждом вызове заданных процедур их значение будет обнуляться.

Ключевые слова Private, Public и Static

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

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

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

Sub GetLocal_1()
Static LVar As Integer
    ' Увеличиваем значение на 2
    LVar = LVar + 2
    Label2.Caption = "Локальное значение " & LVar
End Sub
Sub GetLocal_2()
Static LVar As Integer
    ' Увеличиваем значение на 3
    LVar = LVar + 3
    Label3.Caption = "Локальное значение " & LVar
End Sub

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

Источник

When writing VBA macros, the concept of Private or Public is important. It defines how VBA code within one module can interact with VBA code in another module. This concept applies to both Private Subs and Private Functions.

As a simple analogy – on social media, you can set parts of your profile so that everybody can see it (Public), or only those you allow, such as friends or followers, to see it (Private). The Private vs. Public concept in VBA is similar, but since we’re talking about VBA here, it’s not quite as straightforward.

Before we launch into the difference between Public and Private, we first need to understand what Modules are and how they work.

Modules

Modules are the place where VBA code is written and stored. There are many different module types in Excel, and we use each module for a different purpose.

Worksheet Modules

Worksheet Modules are generally used to trigger code related to that specific worksheet. Each worksheet contains its own module, so if there are 6 worksheets, then we have 6 Worksheet Modules.

In the screenshot above, the VBA code is contained within the Worksheet Module of Sheet1. As we have used the Worksheet_Activate event, the code is triggered only when Sheet1 is activated. Any event-based code (such as worksheet activation) in a Worksheet Module only applies to the worksheet in which the code is stored.

Workbook Module

The Workbook Module is generally used to trigger code related to workbook-level events.

In the screenshot above, we have used the Workbook_Open event. Therefore, the VBA code will run when a workbook is opened. Every workbook has its own module.

UserForm Module

UserForm Modules generally contain code that relates to UserForm events. Each UserForm has its own module.

In the screenshot above, the VBA code will run when the user clicks on CommandButton1 in the UserForm.

Standard Modules

Standard Modules are not related to any specific objects and do not have any events related to them. Therefore, standard Modules are not triggered by user interaction. If we are relying on triggered events, we need the Workbook, Worksheet, or UserForm Modules to track the event. However, that event may then call a macro within a Standard Module.

TIP: Find out how to run a macro from another macro here: Run a macro from a macro (from another workbook)

The screenshot above shows a code that password protects the ActiveSheet, no matter which workbook or worksheet.

Other Module Types

The final type of VBA module available is a Class Module. These are for creating custom objects and operate very differently from the other module types. Class Modules are outside the scope of this post.

The terms Public and Private are used in relation to Modules. The basic concept is that Public variables, Subs, or Functions can be seen and used by all modules in the workbook, while Private variables, Subs, and Functions can only be used by code within the same module.

Declaring a Private Sub or Function

To treat a Sub or Function as Private, we use the Private keyword at the start of the name.

Private Sub nameOfSub()

Private Function nameOfFunction()

Declaring a Public Sub or Function

To treat a Sub or Function as Public, we can use the Public keyword. However, if the word Public or Private is excluded, VBA treats the sub/function as if it were public. As a result, the following are all Public, even though they do not all include the keyword.

Public Sub nameOfSub()
Sub nameOfSub()

Public Function nameOfFunction()
Function nameOfFunction()

Let’s look at Subs and Functions in a bit more detail

Sub procedures (Subs)

When thinking about the difference between a Public Sub and a Private Sub, the two primary considerations are:

Do we want the macro to appear in the list of available macros within Excel’s Macro window?
Do we want the macro to be run from another Macro?

Does it appear in the Macro window?

One of the most important features of Private subs is that they do not appear in Excel’s Macro window.

Let’s assume Module1 contains the following two macros:

Private Sub NotVisible()

MsgBox "This is a Private Sub"

End Sub

Public Sub IAmVisible()

MsgBox "This is a Public Sub"

End Sub

The Macro dialog box only displays the Public sub.

I don’t want you to jump to the conclusion that all Public Subs will appear in the Macro window, as that is not true. Any Public sub which requires arguments, also does not appear in this window, but it can still be executed if we know how to reference it.

Can the code be run from another macro?

When we think about Private Subs, it is best to view them as VBA code that can only be called by other code within the same module. So, for example, if Module1 contains a Private Sub, it cannot be called by any code in another module.

Using a simple example, here is a Private Sub in Module1:

Private Sub ShowMessage()

MsgBox "This is a Private Sub"

End Sub

Now let’s try to call the ShowMessage macro from Module2.

Sub CallAPrivateMacro()

Call ShowMessage

End Sub

Running CallAPrivateMacro generates an error, as the two macros are in different modules.

If the ShowMessage macro in Module1 were a Public Sub, it would execute correctly.

There are many ways to run a macro from another macro. One such method allows us to run a Private Sub from another Module. If we use the Application.Run command, it will happily run a Private sub. Let’s change the code in Module2 to include the Application.Run command:

Sub CallAPrivateMacro()

Application.Run "ShowMessage"

End Sub

Instead of an error, the code above will execute the ShowMessage macro.

Working with object-based module events

Excel creates the Worksheet, Workbook, and UserForm Module events as Private by default, but they don’t need to be. If they are changed to Public, they can be called from other modules. Let’s look at an example.

Enter the following code into the Workbook Module (notice that I have changed it to a Public sub).

Public Sub Workbook_Open()

MsgBox "Workbook Opened"

End Sub

We can call this from another macro by using the object’s name followed by the name of the Public sub.

Sub RunWorkbook_Open()

Call ThisWorkbook.Workbook_Open

End Sub

This means that we can run the Workbook_Open event whenever we need to. If the sub in the Workbook Module is Private, we can still use the Application.Run method noted above.

Functions

VBA functions are used to return calculated values. They have two primary uses:

To calculate a value within a cell on a worksheet (known as User Defined Functions)
To calculate a value within the VBA code

Like Subs, Functions created without the Private or Public declaration are treated as Public.

Calculating values within the worksheet (User Defined Functions)

User Defined Functions are worksheet formulas that operate similarly to other Excel functions, such as SUMIFS or XLOOKUP.

The following code snippets are included within Module1:

Public Function IAmVisible(myText As String)

IAmVisible = myText

End Function

Private Function NotVisible(myText As String)

NotVisible = myText

End Function

If we look at the Insert Function dialog box, the IAmVisible function is available as a worksheet function.

Functions must be declared in a Standard Module to be used as User Defined Functions in an Excel worksheet.

Function within the VBA Code

Functions used within VBA code operate in the same way as subs; Private functions should only be visible from within the same module. Once again, we can revert to the Application.Run command to use a Private function from another module.

Let’s assume the following code were entered into Module2:

Sub CallAPrivateFunction()

MsgBox Application.Run("NotVisible", "This is a Private Function")

End Sub

The code above will happily call the NotVisible private function from Module1.

Variables

Variables hold values or references to objects that change while the macro runs. Variables come in 3 varieties, Public, Private and Dim.

Public Variables

Public variables must be declared at the top of the code module, directly after the Option Explicit statement (if you have one), and before any Subs or Functions.

The following is incorrect and will create an error if we try to use the Public Variable.

Option Explicit

Sub SomethingElseAtTheTop()
MsgBox "Public Variable is not first"
End Sub

Public myPublicMessage As String

The correct approach would be: (The Public variable is declared before any subs or functions):

Option Explicit

Public myPublicMessage As String

Sub SomethingAfterPrivateVariables()
MsgBox "Public Variable is first"
End Sub

As it is a Public variable, we can use and change the variable from any module (of any type) in the workbook. Look at this example code below, which could run from Module2:

Sub UsePublicVariable()

myPublicMessage = "This is Public"
MsgBox myPublicMessage

End Sub

Private Variables

Private Variables can only be accessed and changed by subs and functions within the same Module. They too, must also be declared at the top of the VBA code.

The following demonstrates an acceptable usage of a Private variable.

Module1:

Option Explicit

Private myPrivateMessage As String


Sub UsePrivateVariable()

myPrivateMessage = "This is Private"
MsgBox myPrivateMessage

End Sub

Dim Variables

Most of us learn to create variables by using the word Dim. However, Dim variables behave differently depending on how they are declared.

Dim variables declared within a Sub or Function can only be used within that Sub or Function. In the example below, the Dim has been declared inside a Sub called CreateDim, but used within a sub called UseDim. If we run the UseDim code, it cannot find the Dim variable and will error.

Sub CreateDim()

Dim myDimMessage

End Sub

Sub UseDim()

myDimMessage = "Dim inside Sub"

MsgBox myDimMessage

End Sub

If a Dim variable is created at the top of the module, before all the Subs or Functions, it operates like a Private variable. The following code will run correctly.

Option Explicit

Dim myDimMessage


Sub UseDim()

myDimMessage = "Dim inside Sub"

MsgBox myDimMessage

End Sub

Does this really matter?

You might think it sounds easier to create everything as Public; then it can be used anywhere. A logical, but dangerous conclusion. It is much better to control all sections of the code. Ask yourself, if somebody were to use your macro from Excel’s Macro window, should it work? Or if somebody ran your function as a User Defined Function, should it work? Answers to these questions are a good guiding principle to help decide between Public and Private.

It is always much better to limit the scope of your Subs, Functions, and variables initially, then expand them when required in specific circumstances.

About the author

Hey, I’m Mark, and I run Excel Off The Grid.

My parents tell me that at the age of 7 I declared I was going to become a qualified accountant. I was either psychic or had no imagination, as that is exactly what happened. However, it wasn’t until I was 35 that my journey really began.

In 2015, I started a new job, for which I was regularly working after 10pm. As a result, I rarely saw my children during the week. So, I started searching for the secrets to automating Excel. I discovered that by building a small number of simple tools, I could combine them together in different ways to automate nearly all my regular tasks. This meant I could work less hours (and I got pay raises!). Today, I teach these techniques to other professionals in our training program so they too can spend less time at work (and more time with their children and doing the things they love).

Do you need help adapting this post to your needs?

I’m guessing the examples in this post don’t exactly match your situation. We all use Excel differently, so it’s impossible to write a post that will meet everybody’s needs. By taking the time to understand the techniques and principles in this post (and elsewhere on this site), you should be able to adapt it to your needs.

But, if you’re still struggling you should:

Read other blogs, or watch YouTube videos on the same topic. You will benefit much more by discovering your own solutions.
Ask the ‘Excel Ninja’ in your office. It’s amazing what things other people know.
Ask a question in a forum like Mr Excel, or the Microsoft Answers Community. Remember, the people on these forums are generally giving their time for free. So take care to craft your question, make sure it’s clear and concise. List all the things you’ve tried, and provide screenshots, code segments and example workbooks.
Use Excel Rescue, who are my consultancy partner. They help by providing solutions to smaller Excel problems.

What next?
Don’t go yet, there is plenty more to learn on Excel Off The Grid. Check out the latest posts:

Источник

“Public Variables” in VBA, as the name suggests, are variables that are declared to use publicly for all the macros we write in the same module and different modules. So, when one declares the variables at the start of any Macro are called “public variables” or “global variables.”

Public Variables in VBA
- How to Declare Public Variables in VBA?
  - #1 – Module Level Variables
  - #2 – Declare Variables use them Publicly
- Things to Remember
- Recommended Articles

How to Declare Public Variables in VBA?

Usually, we start the VBA subprocedureSUB in VBA is a procedure which contains all the code which automatically gives the statement of end sub and the middle portion is used for coding. Sub statement can be both public and private and the name of the subprocedure is mandatory in VBA.read more, and inside them, we declare our variables. It is the common practice we all have done until this article.

You can download this VBA Public Variables Excel Template here – VBA Public Variables Excel Template

Every time we write a new subprocedure, we declare new variables with data types assigned to them. But today, we will say goodbye to repetitive variables across subprocedures.

Let us recollect the old style. Below is the code we have written with a single variable.

In the sub procedure “Public_Variable,” we have declared this variable. Now, we cannot use any of the other modules.

Now, in the subprocedure “Public_Variable1,” we cannot use the variable “Var1,” which one can declare in the first subprocedure “Public_Variable.” It is the limitation of declaring variables inside the subprocedures.

#1 – Module Level Variables

As we all know, we write Macros in modules. We can insert several modules. We can declare two kinds of “Public Variables” in VBA. One is to use the variables for all the subprocedures in the same module. The second one is to use the variables for all the subprocedures across all modules.

First, we will see declaring public variables in VBA at the module level.

To use the variables for all the sub procedures in the same module, we need to declare the variables at the top of the module before we start any macros.

Below is the example screenshot for your understanding.

As we can see in the above image, we have declared two variables before we start any macro in the module. So now, we can use these two variables in any Macros in this module.

Inside the sub procedure, start typing the variable name. You can see the IntelliSense list will show up variables names.

Now, we can use these variables in all the macros we write in “Module1.”

These variables are limited to use in this module only. For example, now, we will insert one more module and write a new Macro.

In Module2, we cannot use those variables we have declared in “Module1”.

So, how can we make these variables public in VBA to use across all modules and sub procedures?

#2 – Declare Variables use them Publicly

Go back to “Module1” in this module. We have declared variables before we start writing the way of the Macro and also what world we have used to declare those variables.

We have traditionally used the “DIM” word to declare these variables.

When we use only the “DIM” word, it is limited to be used across all Macros but in the same module.

Instead of the word “DIM,” we need to use the word either “PUBLIC” or “GLOBAL” to make them available to use across all modules of Macros.

We have used the word “Global” to make the variable declaration public. You can also use the word “Public.”

So, by using the words “Global” and “Public,” we can declare variables that we can use for all the Macros across modules.

Things to Remember

It is a good practice to declare variables publicly but needs ample experience before declaring them.
Once the Macros start to run across, the Macro’s value of the variable will be the same.
Assign the particular value to the variable inside the specific Macro only to avoid confusion.

Excel VBA Public Variable

Variable is an important part of a programmers life. Every time a programmer codes he creates some set of variables. A variable can be considered as a voucher which we frequently use on online shopping sites such as Flipkart, Amazon, etc. that voucher allows you to have a certain discount on certain products predefine. Same is the case with a variable. A variable can grammatically be defined as a placeholder which reserves some memory in the system with certain name. That memory space can then be utilized anytime with the same name.

A VBA variable is considered as a public variable in two circumstances. When –

It can be used along with all the codes within a module.
It can be used along all within all the codes for different modules.

In layman terms, a variable is considered as a public variable when it can be used in any code and in any module. In this article, we are about to see, how a variable can be defined. How it can be defined publicly within VBA.

Before starting the concept of VBA Public Variable, we need to understand that the variables which are used in one sub-procedure can’t be used in the other sub-procedure (that is where we started to feel the need of having a public variable which can be used across any module, any sub-procedure).

Suppose we create a sub-procedure in a VBA and define a new variable there using Dim statement.

In this code, var1 is the variable defined under sub procedure Ex_Var.

Now, I will define a new sub-procedure and irony is, I can’t use previously defined var1 in this sub-procedure. See the screenshot below, where I am trying to assign value 10 to var1 under different sub-procedure. See the error message as well after we run the code.

By declaring variables under sub-procedures, we restrict them to be used by that sub-procedure only. It is a major drawback of declaring a variable within a sub-procedure.

This leads to the new theory, which includes the variable declaration outside the sub-procedures. This will help the programmer to use the defined variables widely with different subprocedures.

How to Declare Public Variables in VBA?

Let us look at a few examples to declare public variables in VBA.

You can download this VBA Public Variables Excel Template here – VBA Public Variables Excel Template

Example #1 – Defining a Variable Publicly Within a Module

Suppose we want to define a variable which can be accessed publicly across all the codes within a single module. We can do that. Follow the steps below:

Step 1: Open your Visual Basic Editor (VBE) by hitting Alt + F11 or clicking the Visual Basic button under Developers tab in Excel. Select Insert tab, navigate to Modules and click on it. It will add a new module within the VBE to work on.

Step 2: Within the newly created module, add Option Explicit command at the start of your VBA code (before creating any variable). Option Explicit helps you if there is any typo while using the defined variable. If the used variable is not defined in the system, this option throws an error message saying the variable is not defined.

Code:

Option Explicit

Step 3: Use a Dim statement to create a new variable named my_name with data type as String.

Code:

Option Explicit

Dim my_name As String

If you could pay attention, we have defined this variable explicitly. Meaning, it is not a part of specific sub-procedure. Which automatically makes this variable available for all the codes within the module created (Module1). This is called as defining a variable publicly within a module. This variable can be used anywhere across the multiple sub-procedures within the same module.

Suppose the code given below, I have assigned value to variable my_name as “Lalit Salunkhe”.

Code:

Option Explicit

Dim my_name As String

Sub Ex_1()

my_name = "Lalit Salunkhe"
MsgBox "My name is: " & my_name

End Sub

If I run this code, I will see a message box as shown in the screenshot below:

We can also use this variable in different sub-proc within the same module. See the screenshot given below:

Code:

Option Explicit

Dim my_name As String

Sub Ex_1()

my_name = "Lalit Salunkhe"
MsgBox "My name is: " & my_name

End Sub

Sub Ex_2()

Dim my_age As Integer
my_name = "Lalit Salunkhe"
my_age = 28
MsgBox "My name is: " & my_name & "; My age is: " & my_age

End Sub

See the Ex_2 sub-proc. It has a new variable defined my_age. I have used my_name to add my name and my_age to add the current age of mine. You can see my_name is still accessible within the second sub-procedure. Once I run this code, we can get the output as a message box shown below:

This is how we can define a variable publicly within a module.

Example #2 – Define a Variable Publicly Across all the Modules

In order to achieve this feat, you need to use the keywords as Public or Global instead of Dim which sets the variable as public for all the module wherever you work across.

Step 1: Create a new module. Go to Insert tab, click on Module to add a new module under VBE.

Step 2: Add Option Explicit within the module.

Code:

Option Explicit

Step 3: Define a new variable named var1 and var2 both as a type integer. But this time using Public statement instead of Dim (which we used previously).

Code:

Option Explicit

Public var1 As Integer
Public var2 As Integer

Step 4: Now, these two variables can be used across multiple modules if created under the same VBE. See the example given below:

Code:

Option Explicit

Public var1 As Integer
Public var2 As Integer

Sub Ex_3()

var1 = 10
var2 = 100
MsgBox "Value for var1 is: " & var1 & Chr(13) & "Value for var2 is: " & var2

End Sub

We have assigned the values to both of the variables using a MsgBox feature, trying to display values for those two variables.

Step 5: Run the code by pressing F5 key or by clicking on Play Button, you can see an output as shown below:

Step 6: We will use the same variables under Module1 which we have used in the first example and try to figure out whether the variables are accessible there or not.

Code:

Option Explicit

Dim my_name As String

Sub Ex_1()

my_name = "Lalit Salunkhe"
MsgBox "My name is: " & my_name

End Sub

Sub Ex_2()

Dim my_age As Integer
my_name = "Lalit Salunkhe"
my_age = 28
MsgBox "My name is: " & my_name & "; My age is: " & my_age

End Sub

Sub Ex_public()

var1 = 1000
var2 = 999
MsgBox "Value for var1 is: " & var1 & Chr(13) & "Value for var2 is: " & var2

End Sub

If you could see the screenshot above, we have used the same set of variables defined under Module2 and have values like 1000 and 999 respectively. We are using MsgBox function to present the values of these two variables respectively. Run the code and you can see the output as below:

This is how a variable can be used publicly within the module and across the modules.

Things to Remember

It is always preferred to define the variables explicitly in VBA. So that they are not limited to the sub-procedure they are defined within.
You can assign public variable in two ways: one within a module using conventional Dim statement and second across all the modules present in VBE using either of the Public or Global statement.

Объявление глобальной переменной

Обращение к глобальной переменной

Переменная в стандартном модуле

Переменная в модуле книги

Переменная в модуле листа

Переменная в модуле формы

Переменная в личной книге макросов

Что такое переменная и как правильно её объявить?

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

Открытая переменная Excel VBA

Как объявить публичные переменные в VBA?

Пример № 1 — Публичное определение переменной в модуле

Пример № 2 — Определение переменной публично для всех модулей

То, что нужно запомнить

Рекомендуемые статьи

Общие сведения об области и видимости

Область на уровне процедуры

Область на уровне частного модуля

Область на уровне общедоступного модуля

См. также

Поддержка и обратная связь

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

Оператор Public

Оператор Private

Оператор Static

Оператор Option Explicit

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

См. также

Поддержка и обратная связь

Understanding scope and visibility

Procedure-level scope

Private module-level scope

Public module-level scope

See also

Support and feedback

Declaring variables

Public statement

Private statement

Static statement

Option Explicit statement

Declaring an object variable for automation

See also

Support and feedback

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

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

Ключевые слова Private, Public и Static

Modules

Worksheet Modules

Workbook Module

UserForm Module

Standard Modules

Other Module Types

Sub procedures (Subs)

Does it appear in the Macro window?

Can the code be run from another macro?

Working with object-based module events

Functions

Calculating values within the worksheet (User Defined Functions)

Function within the VBA Code

Variables

Public Variables

Private Variables

Dim Variables

Does this really matter?

Table of contents

How to Declare Public Variables in VBA?

#1 – Module Level Variables

#2 – Declare Variables use them Publicly

Things to Remember

Recommended Articles

Excel VBA Public Variable

How to Declare Public Variables in VBA?

Example #1 – Defining a Variable Publicly Within a Module

Example #2 – Define a Variable Publicly Across all the Modules

Things to Remember

Recommended Articles