# Option Explicit
Therefore, you should always have Option Explicit On as you could misspel a variable during assignment, which cause your program to behave unexpectedly.
# How to switch it on?
Document level
It is on by default, but you can have an extra layer of protection by placing Option Explicit On at the top of the code file. The option will apply to the whole document.
Project level
You can switch it on via the menu in Visual Studio:
Project > [Project] Properties > Compile Tab > Option Explicit
Choose On in the drop-down menu. The option will apply to the whole document.
All new projects
You can switch it On by default for all new Projects by selecting:
Tools > Options > Projects and Solutions > VB defaults > Option Explicit
Choose On in the drop-down menu.
# Remarks
Option Explicit On is a recommended good practice with Visual Basic .Net. It helps you as the developer to produce cleaner, more stable, more bug-free, more maintainable code. In some cases it may also help you write programs with better performance too!
(opens new window) option strict is also can be used instead of option explicit. Option strict inherits option explicit.
Option explicit что это
Все, пора поговорить о переменных. Перегружать информацией я тебя не буду, но минимум знать надо.
Очень желательно, чтобы программа начиналась с инструкции Option Explicit в секции General. Эта инструкция заставляет программиста явно объявлять переменные. При ее отсутствии всякое слово, не противоречащее синтаксису VB, может быть переменной.
Что происходит, если мы не используем инструкцию Option Explicit? А то, что мы вообще можем не объявлять переменные. Это ведь здорово! А вот и нет! А почему нет, видно из следующего:
При отсутствии Option Explicit, если нам нужна новая переменная, мы просто вводим ее в код программы, например,
и опс, Visual Basic уже подсуетился и зарезервировал для переменной памяти, причем зарезервировал по полной программе — максимально. Дело в том, что если явно не задавать тип переменнной, VB считает переменную типом Variant, так как такая переменная может содержать почти любые данные: и целые, и дробные, и строковые. Зато и памяти эта переменная использует очень много. Если же мы явно объявим переменную и зададим ее тип сообразно с нашими потребностями, то рациональное использование памяти — на лицо.
Если тебя это соображение не убедило, то представим ситуацию, когда ты повторно используешь свою переменную для, например, изменения ее значения. И при этом делаешь опечатку (а опечаток делается очень много), пропускаешь букву h:
Для Visual Basic в этом никакой ошибки нет. Он при компиляции быстренько резервирует память под новую переменную NewCislo, считая ее типом Variant и у него никаких проблем. Проблемы у тебя. И критичные. Во-первых, ты имеешь ненужную переменную NewCislo со значением 1, о которой ты знать не знаешь. Во-вторых, если ты ожидаешь, что значение твоей начальной переменной NewChislo увеличилось на 1 и стало 8, то это совершенно напрасно. А вот ожидать, что результат выполнения твоей программы даст непредсказуемый результат можно смело.
Иное дело, если ты использовал инструкцию Option Explicit. В этом случае, при запуске программы, Visual Basic тут же найдет новую необъявленную переменную и остановит выполнение программы на строке с ошибкой.
Если я тебя убедил, тогда, чтобы не писать инструкцию Option Explicit в каждом новом проекте, нажми кнопку “Инструменты” (Tools), выбери “Опции” и в окрывшемся окне на вкладке “Редактор” поставь галочку напротив надписи “Требовать определение переменной”, потом OK. Теперь, всякий раз при создании нового проекта (но только нового, в старые эту инструкцию надо прописывать в (General) вручную.), VB сам, автоматически, будет прописывать Option Explicit .
Любое слово, кроме зарезервированных VB, можно сделать именем переменной. Но начинаться имя должно с буквенного символа. Например Peremenaia, Ima1, X, LastNumber, z001. Не надо использовать в именах математические операторы. И нельзя объявлять две переменные с одинаковыми именами. В принципе, для удобства чтения кода и солидности существуют определенные рекомендованные правила (что-то вроде стандартов) написания имен переменных. Но, так как использование этих правил — сугубо личное дело каждого, я их придерживаться не буду. Если охота, поищи в Интернете что-нибудь про Венгерское соглашение, Венгерскую нотацию или соглашение Реддика.
Итак, при явном объвлении переменной очень желательно явно задавать ее тип. В крайне редких случаях, когда тип хранимых данных в переменной заранее неизвестен, используется как раз тип Variant. В Visual Basic наиболее часто используются следующие типы данных (а соответственно переменных):
Long ‘длинное целое число со знаком от –2 147 483 648 до 2 147 483 647
Integer ‘целое число со знаком от –32 768 до 32767
String ‘строка символов
Boolean ‘логическое, принимает два значения или “True” (Истина) или “False” (Ложь)
Пока что нам этого хватит. Если интересно, то перечень типов данных, поддерживаемые VB, можно посмотреть здесь.
Теперь, где и как их объявлять. Если ты объявишь переменную в теле процедуры объекта, например кнопки, то доступна она будет только в этой процедуре. В другой, скажем, кнопке, ее использовать нельзя. Чтобы переменную использовать во всей форме, надо объявить ее в разделе деклараций (это в самом верху кода – (General) – (Declarations). Для этих случаев можно использовать инструкцию Dim. Ну, а чтоб она была доступна во всей программе (в разных, например, формах) она должна быть объявлена в стандартном модуле с ключевым словом Public. Но модулей мы пока не создавали и оставим это до поры в стороне. Ну вот, на первое время этого о переменных хватит. Чтобы было совсем понятно, вот пример объявления переменных:
Option Explicit
Dim MyStream As String
Dim K14 As Long
Dim Flag As Boolean
Dim Numder As Integer
Private Sub Form_Load()
Dim Flag2 As Boolean
Dim m99little As String
End Sub
| Таймер. Программа “Часики”. |
Теперь разберем использование нового объекта — Timer (таймера). Слева, где компоненты формы, они же инструменты-элементы, нарисован такой будильничек. Это таймер и есть. Он всегда невидимый, но нужный элемент. Всего их одновременно можно использовать около 30 штук. Но нам такое количество таймеров не надо.
Создадим новый exe-проект и поместим один таймер на форму. На основе его мы сделаем сейчас маленькие часики. В свойствах этого таймера поставьте следующие установки:
Enabled – False (по умолчанию True) означает, что таймер выключен
Interval – 1000 (время, в миллисекундах, через которое таймер срабатывает, если конечно включен). Таймер будет срабатывать каждые 1000 мск, т.е. каждую секунду, как в нормальных часах.
Кроме того, нам понадобятся три лейбла: Label1 для секунд, Label2 для минут и Label3 – сами догадайтесь для чего. Правильно, для часов. Все.
Изменим свойства лейблов следующим образом:
Alignment – 2-Центровка (Это чтоб цифры были по центру лейблов)
BorderStyle – 1-Фиксировано (это чтоб размер формы нельзя было изменить)
Caption – 00 (на всякий случай, т.е. значение лейблов изначально будет “00”)
Нажми Font и выбери размер шрифта 14, а начертание – полужирное. После этого подбери подходящий размер окон Лейблов, чтобы цифры в них выглядели симпатично.
Должно получиться как на рис.8.
Создадим процедуру Form_Load .
Option Explicit
Private Sub Form1_Load()
З атем в теле процедуры, как у всякой приличной программы, меняем заголовок формы.
Form1.Caption = "Часики"
Дальше, для того, чтобы наши часы сразу показывали текущее время, надо его взять из компьютера. Чтобы получить системное время, есть функция Time (Label1.Caption=Time). Но она дает полное время одной строкой (16:23:42). Нам тогда придется выбирать из нее секунды, минуты и часы, чтобы распихать по свои лейблам. А чтобы этого не делать, можно взять готовые функции, которые предоставят нам это все по частям:
Label1.Caption = Second(Time) ‘стало быть секунды
Label2.Caption = Minute(Time) ‘ну, минуты
Label3.Caption = Hour(Time) ‘ и часы
Теперь, при запуске того, что мы наваяли, у нас будет показываться текущее время. Это, конечно, прогресс, но вот только часики-то стоят. Трясти монитор не стоит, они от этого не пойдут, а вот запустить таймер одной простой строчкой мы сможем:
Timer1.Enabled = True
Вот она, булева алгебра (ну еще не алгебра, но уже кое-что). То есть Timer1.Enabled может быть либо включен ( True ) , либо выключен ( False ). На этом п роцедура Form1_Load() закончена:
Чтобы получить хоть какие-нибудь блага от запущенного таймера и заставить наши часики ходить, создадим процедуру, которая будет исполняться при наступлении события срабатывания таймера. Событие это у таймера единственное и называется тоже .Timer. Возникает оно в тот момент, когда таймер досчитывает до предела, установленного в свойстве Interval и соответственно сбрасывается на ноль.
Private Sub Timer1_Timer()
Наши секунды должны увеличиваться на одну за каждое срабатывание таймера. Поэтому пишем счетчик, который будет увеличивать значение наших секунд на единицу при каждом срабатывании таймера:
Label1.Caption = Label1.Caption + 1
И вот мы вплотную подошли к проблеме условного оператора (а лучше инструкции) If, без которого — никуда. Суть этой инструкции в том, что он позволяет при неком создавшемся условии производить изменения в ходе программы в зависимости от этого условия.
| Инструкция условия If. |
Этоу инструкцию можно использовать в блоковой форме: полном (развернутом) виде и неполном (без строк ElseIf), а также в одну строку.
В полном виде в блоковой форме синтаксис этой инструкции будет выглядеть следующим образом:
If Условие1 Then
группа операторов1
ElseIf Условие2 Then
группа операторов2
.
ElseIf УсловиеN Then
группа операторовN
Else
Последняя группа операторов
End If
Условие представляет из себя оператор, значение которого может принимать True (Истина) или False (Ложь). Например, если Условие1 представляет из себя выражение X>1, то оно истинно, если X равно 2, то оно ложно при значении X равном 1. Если Условие1 истинно, то выполняется группа операторов1, остальные группы операторов не выполняются, если даже в каких-нибудь последующих ветках УсловиеN истинно. Если Условие1 ложно, то группа операторов1 не выполняется, а производится проверка Условие2 в следующей ветке ElseIf . И опять же, если Условие2 истинно, то выполняется группа операторов2, последующие группы операторов не выполняются и их условия не проверяются. В противном случае происходит переход к следующей ветке ElseIf . Если ни в одной ветке нет истинных операторов, выполняется последняя группа операторов вне зависимости от каких-либо условий. Логическая схема инструкции If представлена в таблице:
Объявление переменных в VBA или одна неочевидная особенность языка, показывающая, читали ли вы манул или учились на практике
Всё, что написано ниже, относится к VBA, реализованному внутри Excel из комплекта Office 365 по состоянию на февраль 2021 года. Скорее всего, всё обстоит так же и в остальных версиях офиса, насколько помню — с 97.
Что такое переменные, зачем они нужны и прочие базовые принципы я пропущу, здесь всё достаточно очевидно(*) даже на уровне ощущений.
Но есть одна особенность, которая неочевидна, упомянута в мануле одной строкой, и в корне отличается от реализации в других диалектах VB — например, в .NET.
Во-первых, примем как должное, что код в VBA в любом (во всех!) модулях должен начинаться со строки
Это не обязательное требование, но оно сродни требованию включать поворотник при любом манёвре и пристёгиваться до начала движения: однажды оно спасёт вам жизнь, а для этого должно стать — даже не привычкой — рефлексом.
Не будем говорить про стиль написания кода — тут больше вопрос собственного удобства, но иногда хочется или необходимо объявить несколько переменных в одной строке
Простейшая задача: объявить в одной строке две строковые переменные — вызывает лютое желание написать
Эта строчка абсолютно корректна с точки зрения синтаксиса, будет работать почти всегда, однако, делает она совсем не то, что было задано. А именно, она объявляет одну строковую переменную и одну — нетипизированную.
Нетипизированные переменные, напомню, получают тот тип, который имеют записанные в них данные, и могут менять тип в процессе выполнения кода. Как любая мощная магия, они требуют понимания как оно работают и умения обращаться с ними.
По большому счёту, код с нетипизироанными переменными работает ровно так же, как и с типизированными. Отличие в том, что он делает не то, что вы задумали, а то, что понял интерпретатор из ваших косноязычных объяснений.
Пример кода, объясняющего происходящее:
Как видно, переменная S1 в начале выполнения кода вовсе не имеет типа (Empty), а потом меняет его несколько раз.
В то же время, S2 также принимает разные значения, при этом всегда оставаясь строковой. В её случае происходит неявное преобразование данных разных типов к строковому типу.
Данное поведение описано в документации по VBA https://docs.microsoft.com/ru-ru/office/vba/language/concept.
Хотя кто будет читать документацию! Особенно с раздела «объявление переменных». Особенно, если уже имеешь опыт программирования вообще и на похожем языке в частности.
Данная особенность VBA неочевидна. Более того, в VB для .NET данная конструкция ведёт себя противоположным образом: https://docs.microsoft.com/ru-ru/dotnet/visual-basic/program.
Резюмируя:
1. Option Explicit — желательна и рекомендуется.
2. При определении переменных нужно учитывать особенность VBA.
————————————————————
(*)Читать документацию нужно с самого начала, даже если кажется, что всё это знаешь.
Option Explicit. Требование явного объявления переменных
В предыдущей статье уже рассматривались способы явного и неявного объявления переменных, но стоит отдельно обратить внимание на такую команду VBA, как Option Explicit. Не смотря на то, что неявное объявление переменных простым их использованием удобно, с ним могут быть связаны определенные проблемы. При неявном объявлении переменной существует риск случайно создать новую переменную, когда необходимо использовать уже существующую. Такая ситуация может приводить к ошибкам, которые очень сложно выявлять. Использование оператора Dim для объявления переменных не всегда помогает предотвращать ошибки в коде, относящиеся к неявному объявлению переменных.
Для того, чтобы было проще обнаруживать ошибки, связанные с неявным объявлением переменных, в VBA предусмотрена команда Option Explicit. Использование Option Explicit препятствует неявному объявлению переменных, при этом VBA требует объявления всех переменных с использованием оператора Dim. Такие команды, как Option Explicit, называются директивами компилятора и инструктируют VBA о специфических правилах, которым должен следовать VBA при компиляции исходного кода. Option Explicit действует только в пределах модуля, в котором она прописана.
Для того чтобы установить режим Option Explicit, при котором VBA требует явного объявления всех переменных в модуле, необходимо добавить команду Option Explicit в начало модуля, перед любыми объявлениями переменных.
Если добавить неявное объявление переменной в этот модуль, VBA отобразит ошибку времени исполнения, сообщая о том, что переменная является необъявленной.
Редактором Visual Basic предусмотрена возможность автоматически включать Option Explicit в каждый новый модуль при его создании. Для этого необходимо в редакторе VB зайти в меню Tools/Options и в диалоговом окне «Options» на вкладке «Editor» поставить флажок перед опцией Require Variable Declaration (явное описание переменных).