Описание языка VBScript
Содержание :
  1. Вступление
  2. Операторы
  3. Арифметические и логические операции
  4. Отличие от стандарта Basic
Вступление
Почему VBScript является именно VB, а не скажем C++, от которого произошло огромное кол-во дочерних языков-скриптов, таких как: Java, PHP, CGI? Всё очень просто: C++ хоть и является по своей сути очень мощным языком, но точно в такой же степени он является запутанным и сложным для понимания его основ новичками. Так же выбор пал на VB, а не на Pascal только потому, что несмотря на их высокую схожесть, VB все же остается более простым и более известным языком нежели Pascal, благодаря старанию Microsoft. Вспомним, что пакет MS Office, стоящий на каждом ПК, использует именно этот язык.
Операторы
Function объявление функции
Синтаксис: Function {имя ф-ции} ( [ [byVal,byRef] {имя параметра} ] )
[ {тело ф-ции} ]
End [ Function ]
Пояснение: {имя ф-ции} - стандартное для языка Basic имя, состаящее из букв латиницы и кирилицы, а так же знака _ и цифр. Причем имя должно начинаться только с букв или знака _.
byVal,byRef - необязательные ключевые слова, указывающие способ передачи параметров в ф-цию. По-умолчанию считается установленным byVal
{имя параметра} - имя параметра ф-ции. Кол-во параметров может быть более одного, тогда в этом случае их следует разделить запятой. Если ф-ция не требует параметров вообще, то скобки () оставляются пустыми.
{тело ф-ции} - основной рабочий код ф-ции, который необходимо выполнить
[ Function ] - необязательное ключевое слово, указывающее, что мы завершаем ф-цию, а не что-то ещё.

Для возврата значения ф-ции используется переменная Result или оператор Return( см. Отличие от стандарта Basic  ).
Пример: Function ПриветМир ()
Message ( "Привет Мир!!!" )
End
См. ещё: передача параметров, выход из блоков, Отличие от стандарта Basic
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
If Then Else оператор условия. Выполняет проверку некоторого выражения и осуществляет переход в зависимости от результата
Синтаксис: If { выражение1 } Then
[ { операторы1 } ]
[ Else If { выражение2 } Then ]
[ { операторы2 } ]
[ Else ]
[ { операторы3 } ]
End If
Пояснение: { выражение№ } - любое допустимое в языке Basic математическое выражение.
{ операторы№ } - код, который необходимо выполнить. Причем кол-во операторов не ограничено.
Принцип работы конструкции:
  • вычисляется { выражение1 }
  • Если оно истинно, то выполняются { операторы1 } и затем происходит переход к оператору, стоящему после ключевого слова End If
  • Иначе если блок Else If присутствует, то вычисляется { выражение2 }
  • Если оно истинно, то выполняются { операторы2 } и затем происходит переход к оператору, стоящему после ключевого слова End If
  • Иначе если блок Else присутствует, то выполняются { операторы3 }
  • происходит переход к оператору, стоящему после ключевого слова End If
    Очевидно, что число необязательных секций Else If неограничено, в то время как секция Else может быть только одна, т.к. нет таких значений, которые бы не могли попасть под условие Иначе.
    • Пример: If x > y Then
    Message( "Значение x больше значения y" )
    Else If x = y Then
    Message( "Значение x равно значению y" )
    Else
    Message( "Значение x меньше y!!!!" )
    End If
    См. ещё: Отличие от стандарта Basic
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Select Case выполнение операторов в зависимосте от значения одной переменной или выражения
    Синтаксис: Select [ Case ] [ { выражение1 } ]
    Case { выражение2 } [ : ]
    [ { операторы } ]
    [ Case Else ]
    [ { операторы } ]
    End Select
    Пояснение: [ Case ] - необязательное ключевое слово, оставленное для совместимости с классическим языком Basic
    { выражение1 } - то выражение, значение которого будет проверяться
    { выражение2 } - выражение, с которым сравнивается { выражение1 }. Если требуется записать несколько значений, то используется запятая. Если нужно проверить вхождение { выражение1 } в диапозон значений, то используется оператор .. (две точки ).
    { операторы } - выполняются если { выражение1 } = { выражение2 }
    [ Case Else ] - операторы этой секции выполняются только тогда, когда ни одно из выражения секций Case не было равно { выражение1 }

    Чиссло секций Case не ограничено. Так же следует помнить, что если в блоке имеются две секции Case с одинаковым значением { выражение№ }, то будут выполнены операторы только первой из них.
    В общем конструкция аналогична If Then Else, однако её положительная особенность состоит в том, что { выражение1 } вычисляется только один раз( если это не переменная ) и запись условий в таком виде( если это возможно конечно ) гораздо нагляднее.
    Пример: Age = 14 ' Возраст
    Select Case Age
    Case 10..13 : Message( "Тинейджер" )
    Case 14..17 : Message( "Подросток" )
    Case 18..25 : Message( "Взрослый" )
    Case Else Message( "Ни то, ни се и не другое!!!" )
    End Select
    См. ещё:
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    For Next многократное выполнение блока операторов по счетчику
    Синтаксис: For { переменная } = { выражение1 } To { выражение2 } [ Step {константа или переменная} ]
    [ { операторы } ]
    Next
    Пояснение: { переменная } - переменная счетчика
    { выражение1 } - начальное значение счетчика: устанавливается 1 раз перед началом цикла
    { выражение2 } - выражение, по достижению которого( или превышению ) происходит выход из цикла
    { операторы } - тело цикла
    Step - шаг счетчика. Если он не задан, то считается, что шаг равен 1
    {константа или переменная} - не допускается в качестве шага задавать выражение или ф-цию
    Пример: For i = 1 To 5
    Message( "Итерация - " + i )
    Next
    См. ещё: выход из блоков
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Do Loop многократное выполнение блока операторов по условию
    Синтаксис: Do [ While,Until { выражение } ]
    { операторы }
    Loop [ While,Until { выражение } ]
    Пояснение: While,Until - указывается одно из этих ключевых слов: While - пока выражение Истинно, Until - пока выражение Ложно
    { выражение } - выражение, по которому определяется выход из цикла в зависимости от ключевых слов и их положения
    { операторы } - тело цикла

    Одно из ключевых слов While,Until указывается только после оператора Do или только после оператора Loop. Следует так же отметить ту особенность, что если этих слов не указывать вообще, то ошибки не будет, но получиться бесконечный цикл.
    Пример: x = 1
    Do
    Message( "X = " + x )
    x = x*2
    Loop While x < 100
    См. ещё: выход из блоков
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    ByVal, ByRef способ передачи параметров в ф-цию
    Синтаксис:
    Пояснение: ByVal - передача параметра по значению
    ByRef - передача параметра по ссылке

    Основное отличие ByRef от ByVal состоит в том, что при передаче аргумента по ссылке его изменение в вызванной ф-ции приводит к изменению переменной в вызывающей ф-ции. Чтобы наглядно понять, что это значит см. пример ниже.
    Пример: Function Test1( ByRef x )
    x = "Я изменился"
    End

    Function Test2( ByVal x )
    x = "Я изменился"
    End

    Function Test()
    t = "Я"
    Test1( t )
    Message( t ) ' в окошке сообщения мы увидим текст: Я изменился
    t = "Я"
    Test2( t )
    Message( t ) ' теперь же в окошке сообщения мы увидим: Я
    End
    См. ещё: функция
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Exit преждевременный выход из циклов и ф-ции
    Синтаксис: Exit [ For | Do ]
    Пояснение: Ключевое слово Exit без параметров производит выход из тела ф-ции. Соответственно если дальше следует ключевое слово For, то производиться выход из текущего цикла For Next. Do - выход из текущего цикла Do Loop. Так же для краткости записи предусмотрен оператор Break эквивалентный записи Exit For.
    Пример: For i = 1 To 10
    Message( i )
    If i = 3 Then Exit For End If
    Next
    См. ещё: цикл со счетчиком, цикл с условием,  оператор условия, функция
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Dim As объявление переменной
    Синтаксис: Dim { имя } [ As { тип } ]
    Пояснение: { имя } - любое допустимое в VBScript имя
    { тип } - тип переменной: String - строка, Integer - целое число, Real - действительное число

    При необходимости объявить несколько переменных, используется запятая.
    Пример: Dim X As Real,Y As Real
    Dim k[1][2]
    Dim Текст[3] As String
    См. ещё: Отличие от стандарта Basic
    Арифметические и логические операции
    Пояснения к обозначениям в таблице:

    -> - указывает результат, возвращаемый операцией

    Операции Or,And и Not логические поэтому их операнды могут иметь только 2 значения: Истина(True) и Ложь(False). За Истину считается число целого или действительного типа, не равное 0 или не пустая строка( "" ). Во всех остальных случаях операнд принимается равным значению Ложь.

    Приоритет операций(начиная с наиболее низшего):
    Or
    And
    < >= < <= = <>
    + -
    * /
    + - Not (унарные + -)
    Операция Тип аргументов Описание Пример
    + Integer операция сложения 2 + 2 -> 4
    Real операция сложения 1.1 + 3.9 -> 4.0
    String операция соединения( сцепления ) "Hello " + "world!" -> "Hello world!"
    - Integer операция вычитания 2 - 2 -> 0
    Real операция вычитания 1.1 - 3.9 -> -2.8
    String [нет операции] "Hello " - "world!" -> "Hello "
    * Integer операция умножения 2 * 2 -> 4
    Real операция умножения 1.1 * 3.9 -> 4.29
    String дублирование строки "Hello" * 3 -> "HelloHelloHello"
    / Integer операция деления с возвратом целой части 5 / 2 -> 2
    Real операция деления 6.3 / 2.0 -> 3.15
    String [нет операции] "Hello" / 3 -> "Hello"
    > Integer больше 5 > 2 -> 1 или 2 > 5 -> 0
    Real больше 5.0 > 2.0 -> 1 или 2.0 > 5.0 -> 0
    String сравнение длинны на больше "Hello" > "H" -> 1 или "H" > "Hello" -> 0
    < Integer меньше 5 < 2 -> 0 или 2 < 5 -> 1
    Real меньше 5.0 < 2.0 -> 0 или 2.0 < 5.0 -> 1
    String сравнение длинны на меньше "Hello" < "H" -> 0 или "H" < "Hello" -> 1
    >= Integer больше либо равно 5 >= 2 -> 1 или 2 >= 5 -> 0 или 2 >= 2 -> 1
    Real больше либо равно 5.0 > 2.0 -> 1 или 2.0 > 5.0 -> 0 или 2.0 > 2.0 -> 1
    String сравнение длинны на больше либо равно "Hello" >= "H" -> 1 или "H" >= "Hello" -> 0
    <= Integer меньше либо равно 5 <= 2 -> 0 или 2 <= 5 -> 1 или 2 <= 2 -> 1
    Real меньше либо равно 5.0 <= 2.0 -> 0 или 2.0 <= 5.0 -> 1 или 2.0 <= 2.0 -> 1
    String сравнение длинны на меньше либо равно "Hello" <= "H" -> 0 или "H" <= "Hello" -> 1
    <> Integer не равно 5 <> 2 -> 1 или 2 <> 2 -> 0
    Real не равно 5.0 <> 2.0 -> 1 или 2.0 <> 2.0 -> 0
    String не равно "Hello" <> "H" -> 1 или "Hello" <> "Hello" -> 0
    = Integer равно 5 = 2 -> 0 или 2 = 2 -> 1
    Real равно 5.0 = 2.0 -> 0 или 2.0 = 2.0 -> 1
    String равно "Hello" = "H" -> 0 или "Hello" = "Hello" -> 1
    Or Integer или 5 Or 0 -> 1 или 0 Or 0 -> 0
    Real или 5.0 Or 0.0 -> 1 или 0.0 Or 0.0 -> 0
    String или "Hello" Or "" -> 1 или "" Or "" -> 0
    And Integer и 5 And 0 -> 0 или 0 And 0 -> 0 или 23 And 4 -> 1
    Real и 5.0 And 0.0 -> 0 или 0.0 And 0.0 -> 0 или 23.0 And 4.0 -> 1
    String и "Hello" And "" -> 0 или "" And "" -> 0 или "DF" And "He" -> 1
    Not Integer не Not 5 -> 0 или Not 0 -> 1
    Real не Not 5.0 -> 0 или Not 0.0 -> 1
    String не Not "Hello" -> 0 или Not "" -> 1
    Отличие от стандарта Basic
    Отличий достаточно мало, но во избежание путанницы язык построен так, что обратная совместимость, т.е. от Basic к VBScript почти полностью поддерживается.
    1) Главная особенность VBScript состоит в том, что каждый оператор не обязательно должен начинаться с новой строки. Например:
    If x > 0 And y > 0 Then
    t = x + y
    x = 0
    y = 0
    End If
    а можно записать и так:
    If x > 0 And y > 0
    Then t = x + y x = 0 y = 0 End If
    Конечно нужно быть крайне "одаренным", чтобы писать скрипты в стиле второго способа. Поэтому в VBScript введен дополнительный оператор, делающий код более читабельным:
    If x > 0 And y > 0 Then
    t = x + y; x = 0; y = 0;
    End If
    2) Не нужно объявлять переменные. Одним словом переменная создается при первом её использование в программе, аналогично типу Variant в Basic. Точно так же не указывается тип параметров ф-ции и возвращаемое ею значение. Таким образом, чтобы сделать переменную целого типа достаточно написать x = 0, или строкового x = "". Допускается так же переопределение типа переменной, т.е. сначало ей можно присвоить строку, а потом число. Например:
    var = 34.9 ' var - переменная типа Натуральное Число( Real )
    var = "***" ' теперь var - переменная типа Строка( String )
    Однако не смотря на это, объявление:
    Dim iVal As Integer
    вполне допустимо, но работа с переменной iVal не станет быстрее, как при объявление в Visual Basic. Единственным плюсом явного задания переменной является определение её типа во ВРЕМЯ КОМПИЛЯЦИИ. Чтобы лучше понять о чем речь, посмотрите следущий пример:
    Dim x As Integer
    Message( x ) ' в окне сообщения мы увидим: 0
    Message( y ) ' а теперь в окне сообщения мы увидим: NULL
    Как видно из примера, при объявление переменной x она тут же инициализируется 0, что мы и увидели в окне сообщения. В тоже время тип переменной y не известен до первого присвоения ей какого либо значения, поэтому в сообщение мы увидели NULL(не известный тип данных).
    Так же в VBScript массив объявляется не с круглыми скобками как в Basic, а с квадратными как в C++ или Pascal:
    Dim Arr(10) As Integer ' ошибка! Так объявлять массив нельзя
    Dim Arr[10] As Integer ' теперь массив объявлен верно
    При объявление индекс первого элемента массива начинается с 0. Доступ к элементам тоже осуществляется через квадратные скобки: Arr[3] = 333
    3) Нет короткой записи оператора If . При попытке написать так:
    If x = 0 Then Message( "Икс пустое" )
    интерпретатор выдаст ошибку об отсутствие закрывающего End If
    4) Полностью оптимизированна работа с преобразованием типов. Например вполне допустимо выражение: Message( "2 + 2 = " + 4 ). В выражениях, где используются аргументы разных типов, результат всегда приводиться к типу первого аргумента. Например тот же код, который написан немного выше, но в таком варианте: Message( 2 + " + 2 = 4" ), выдаст не "2 + 2 = 4", как до этого, а просто 2. Произошло это потому, что интерпретатор попытался преобразовать строку " + 2 = 4" к целому типу, а это, совершенно очевидно, невозможно. Поэтому к 2 прибавился 0 и в итоге получилось число 2, которое и вывелось в окно сообщения.
    5) Возвращение результата ф-ции производится путем присвоения его переменной Result( Pascal способ ). Попытка присвоить результат самой ф-ции приведет к ошибке компиляции:
    Function Пример ()
    ' при попытке скомпилировать этот код вы получите сообщение о синтаксической ошибке
    Пример = 666
    End
    .......
    Function Пример ()
    Result = 666 ' этот код скомпилируется без всяких проблем
    End
     
    Так же можно использовать оператор Return ( С++ способ ), обязательным параметром которого является возвращаемый результат:
    Return ( 666 )
    Отличие от Result состоит в том, что оператор помимо возврата значения ф-ции осуществляет ещё и выход из неё. Товоже результата с использованием Result можно было бы достичь и так:
    Result = 666
    Exit
    6) Вызыв ф-ций в VBScript более мягок по сравнению с Basic. Так если в Basic процедуры вызывались всегда без скобок, а ф-ции со скобками, то в VBScript ф-ции( процедур тут нет ) вызывать можно так, как вам кажется правильнее, например:
    Beep( 200, 100 )
    можно записать и так:
    Beep 200, 100
    Не ошибкой будет и такая запись:
    K = Beep 200, 100
    7) Логические операции аналогичны языку C++, т.е. за Истину(True) считается число целого или действительного типа, не равное 0 или не пустая строка( "" ). Всё остальное Ложь(False):
    If 4 Then Message( "Истина" ) End If ' это сообщение мы увидим
    If 0 Then Message( "Ложь" ) End If ' а это нет
    If "" Then Message( "Ложь" ) End If ' и это тоже