Решение: Скрипт vbs авторизации на сайте гугл? – VB ✔

Vbscript для начинающих | vbscript |

Опубликовано: 4 фев 2022 в 12:45

Автор: Dave Child  Перевод: freeeeez 

VBScript — один из языков, используемых для написания ASP страниц. ASP (Active Server Pages) скрипты работают на IIS серверах (или на Apache серверах, используя ChiliASP). И IIS и ASP разработаны компанией Microsoft. При этом, ASP страницы могут быть написаны на одном из нескольких скриптовых языков, наиболее распространенным из которых является VBScript. ASP скрипты исполняются на сервере, что позволяет взаимодействовать с базами данных, обрабатывать входные данные и прочее. Функциональные возможности ASP скриптов сравнимы с Perl и PHP, к тому же, как и PHP, их не надо запускать в CGI-BIN. Есть несколько версий ASP, текущая из которых ASP 3.0.

VBScript содержит семь встроенных объектов, с которыми вы будете работать при написании ASP страниц:

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

ASP страницы имеют расширение “.asp”, например “index.asp”. Страницы, которые имеют данное расширение, при правильной настройке сервера, будут обрабатываться движком ASP, прежде чем возвращаться пользователю. Данные между тегами <% и %> и есть код, обрабатываемых движком.

Наконец, мы подошли к написанию своего первого скрипта. Как и во многих других языках, первое, что вы научитесь делать с ASP, это вывод на страницу знаменитой строки “Hello World!”. “Строка” является общим названием для текстовых данных.

<html>
<body>
<%
Response.Write ("Hello World!")
%>
</ Body>
</ Html>

Скопируйте код в текстовый редактор и сохраните его как “vbscript101.asp”. Загрузите полученый скрипт на сервер, который поддерживает ASP. При загрузке страницы страницы в браузере, вы увидите текст “Hello World!”. Если нет, то данный сервер не поддерживает ASP.

Похожее:  Почему WhatsApp запрашивает разрешения – и как поступить в такой ситуации

Мы сделали нормальную HTML страницу, используя движок ASP для написания текста. Хорошее начало, но это еще не самый полезная функция языка. Далее мы узнаем, как использовать переменные.

Переменные в VBScript просты в использовании, однако могут ввести вас в заблуждение. Чтобы грамотно писать код, вы должны называть свои переменные так, чтобы сразу было видно к какому типу они относяться. Например, переменная, которая содержит имя может быть названа “strName”. Здесь “str” говорит о том, что в переменной содержиться строка или текст, а “Name”, что текст этот — имя. Переменную года рождения можно назвать “intYear”, где “int” говорит о числовом значении переменной.

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

<html>
<body>
<%
dim strHelloWorld //объявление переменной
strHelloWorld = "Hello World, Again!" //присвоение значения
Response.Write(strHelloWorld) //вывод на страницу
%>
</body>
</html>

Обратите внимание, что при использовании Response.Write вы не должны ставить кавычки внутри скобок. Иначе обработчик сценария примет это за текст и выведет на экран “strHelloWorld”, а не текст, который вы присвоили переменной.

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

<html>
<body>
<%
dim intHourOfDay
intHourOfDay = hour(now())
if intHourOfDay < 12 then
    Response.Write("Good Morning World!<br><br>The hour of the day is ") & intHourOfDay
else
    Response.Write("Good Afternoon World!<br><br>The hour of the day is ") & intHourOfDay
end if
%>
</body>
</html>

Начинаем с объявления переменной, intHourOfDay, где “int” напоминает нам, что в дальнейшем эта переменная будет содержать число, а “HourOfDay” говорит о том, что число это — текущий час дня. Далее мы присваиваем переменной текущее время с помощью функции now(), а текущий час с помощью hour(). На данном этапе функция “intHourOfDay” будет содержать текущий час дня.

Затем мы проверяем это значение. Если оно меньше 12, мы знаем, что сейчас утро и напишем соответствующее приветствие, а иначе другое. End if в конце конструкции говорит о завершении разветвления.

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

Поздравляю! Вы сделали свои первые шаги по интерактивному программированию на ASP.

Хотелось бы добавить пару слов о страховке. Сам недавно летал в Болгарию и оформлял страховой полис на сайте Aviabilet.ru. Страхование выезжающих за рубеж проводиться в течение 2-3 минут. После заполнения формы заказа и оплаты, на почту приходит электронная версия страховки, которую нужно распечатать и предоставить в посольство при получении визы. Никогда не поздно застраховаться. Удачного отдыха!

8 979 просмотров

Сценарии для администрирования (часть 2) | system engineering

…продолжение

VBS-скрипт – это мощное решение для автоматизации действий пользователя в системах семейства Windows. Такой тип сценариев обычно используется для:

  • создания сложных сценариев;
  • использования объектов из других приложений и библиотек;
  • скрытия окон в ходе выполнения сценария;
  • шифрования логики сценария.

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

В зависимости от языка сценария, содержания и шифрования встречаются такие типы скриптов:

  • vbs – Visual Basic Script
  • vbe – зашифрованный Visual Basic Script
  • js – Java Script
  • jse – зашифрованный Java Script
  • wsh – настройки скрипта
  • wsf – XML-интегрированный сценарий

В этой статье я буду рассматривать сценарии типа vbs.

Сценарии обычно редактируются в блокноте Windows, но я рекомедую использовать Notepad2, который подсвечивает ключевые слова языка Visual Basic и помогает форматировать тело сценария. Итак, vbs-сценарий – это обычный текстовый файл с именем *.VBS, который легко править в блокноте, а запускать на исполнение – двойным щелчком мыши или вызовом по имени в консоли.

Как уже было описано выше, сценарии не компилируются, а интерпретируются. То есть для обработки скрипта в системе должен присутствовать интерпретатор языка VBS, и таких интерпретатора в Windows есть даже две штуки: оконный WScript и консольный CScript – оба интерпритатора – это Windows Script Host (WSH).

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

CScript //H:CScript

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

CScript //H:WScript

В Visual Basic работают следующие правила:

Рекомендуемая структура сценария:

' === Script Information Header ===
' Script Name:                    ' название сценария;
' Date:                           ' дата изменения;
' Author:                         ' автор;
' Description:                    ' описание;
' === Initialization Block ===
Option Explicit                   ' директива, запрещающая автоматическое создание
                                  ' переменных;
Dim <Variable>                    ' объявление переменных;
Dim <Array>()                     ' объявление массивов;
Set <Object>                      ' подключение объектов;
' === Script Main Logic ===
                                  ' тело сценария;
' === Functions and Procedures ===
                                  ' процедуры и функции;

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

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

Dim <ValueName1>      ' переменная, доступная всем подпрограммам;
Public <ValueName2>   ' переменная, доступная всем подпрограммам;
Private <ValueName3>  ' переменная, доступная только текущей программе и ее подпрограммам;

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

Const <ConstName1> = <Value1>         ' константа, доступная всем подпрограммам;
Public Const <ConstName2> = <Value2>  ' константа, доступная всем подпрограммам;
Private Const <ConstName3> = <Value3> ' константа, доступная только текущей программе
                                      ' и ее подпрограммам.

Тип переменной присваивается автоматически после внесения в нее первого значения. В Visual Basic существуют следующие типы данных:

  • empty – неинициализированная переменная;
  • null – пустая переменная;
  • boolean – логический тип, возможные значения: False, True или 0, 1;
  • byte – 8-битное целое число без знака, возможные значения: 0 .. 255;
  • integer – 32-битное целое число, возможные значения: -32768 .. 32767;
  • long – 64-битное целое число, возможные значения: -2147483648 .. 2147483647;
  • currency – денежный тип, возможные значения: -922337203685477,5808 до 922337203685477,5807;
  • single – число с плавающей точкой, возможные значения: -3.402823e38 .. -1.401298e-45 для отрицательных чисел и 1.401298e-45 .. 3.402823e38 для положительных чисел;
  • double – число с плавающей точкой, возможные значения: 1.79769313486232e308 .. -4.94065645841247e-324 для отрицательных чисел и 4.94065645841247e-324 .. 1.79769313486232e308 для положительных чисел;
  • date – дата, возможные значения: 01.01.1900 и 31.01.9999;
  • string – строковая переменная, вместимость до 2 миллиардов символов;
  • object – указатель на объект;
  • error – код ошибки.

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

VarType(<Value>)    ' возврат номера типа переменной;
TypeName(<Value>)   ' возврат имени типа переменной;
IsArray(<Value>)    ' проверка, что переменная - это массив;
IsDate(<Value>)     ' проверка, что переменная - это дата;
IsEmpty(<Value>)    ' проверка, что переменная неинициализирована;
IsNull(<Value>)     ' проверка, что переменная пустая;
IsNumeric(<Value>)  ' проверка, что переменная - это число;
IsObject(<Value>)   ' проверка, что переменная - это объект;
CCur(<Value>)       ' конвертация в тип currency;
CBool(<Value>)      ' конвертация переменной в тип boolean;
CByte(<Value>)      ' конвертация переменной в тип byte;
CDate(<Value>)      ' конвертация переменной в тип date;
CDbl(<Value>)       ' конвертация переменной в тип double;
CInt(<Value>)       ' конвертация переменной в тип integer;
CLng(<Value>)       ' конвертация переменной в тип long;
CSng(<Value>)       ' конвертация переменной в тип single;
CStr(<Value>)       ' конвертация переменной в тип string.

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

  • iValueName – числовые типы
  • sValueName – строковый тип
  • bValueName – логический тип
  • dValueName – дата
  • oValueName – объект
  • cValueName – константа
  • aArrayName – массив

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

Dim <ArrayName[(Dimention)]>

Пример использования массивов

Dim aMyArray1(10,10)            ' создание статического массива размерностью 11х11;
Dim aMyArray2()                 ' создание динамического массива;
aMyArray1(0,0) = "Hello"        ' заполнение массива;
aMyArray1(0,1) = "People"       ' заполнение массива;
aMyArray1(1,0) = "World"        ' заполнение массива.

Прежде, чем пользоваться динамическим массивом, ему нужно указать текущую размерность с помощью команды ReDim, после чего массив можно переформировать в любом месте сценария, при этом либо очистить весь массив, либо сохранить старые значения ячеек командой Preserve:

ReDim aMyArray2(0)            ' формирование массива из одного элемента;
aMyArray2(0) = "Hello"        ' заполнение массива;
ReDim aMyArray2(1)            ' удаление старого массива и формирование нового из
                              ' друх элементов;
aMyArray2(0) = "Hello"        ' заполнение массива;
aMyArray2(1) = "World"        ' заполнение массива;
ReDim Preserve aMyArray2(2)   ' формирование массива из трех элементов, оставляя
                              ' старые значения элементов в тех ячейках, где они были;
aMyArray2(1) = "!"            ' заполнение массива;
Erase aMyArray2               ' удаляление массива.

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

Ни один полноценный сценарий не обходится без ветвлений, ветвления помогают выбрать верный путь при выполнении или невыполнении какого-то заложенного условия. Иными словами, ветвления реализуют логику сценария. В VBS-сценариях реализованы несколько механизмов ветвлений. Рассмотрим их по порядку.

Конструкция для одного действия, выполняемого по условию:

If <Condition> Then <Action>

Конструкция для нескольких действий, выполняемых по условию:

If <Condition> Then
   <Action>
   <Action>
End if

Конструкция “развилка”:

If <Condition> Then
   <Action>
   <Action>
Else
   <Action>
   <Action>
End if

Конструкция “развилка на несколько путей” (вариант сIf):

If <Condition> Then
   <Action>
   <Action>
ElseIf <Condition> Then
   <Action>
   <Action>
Else
   <Action>
   <Action>
End if

Во всех приведенных выше конструкциях применяется следующее правило: “Если выполняется условие <Condition>, то произвести список действий <Action>, которые расположеные под текущем блоком условия. Если текущее условие не выполняется, то перейти к списку действий <Action> под командой Else.”

Конструкция “развилка на несколько путей” (вариант сSelect):

Select Case <Variable>
   Case <Significance>
       <Action>
       <Action>
   Case <Significance>
       <Action>
       <Action>
   Case Else
       <Action>
       <Action>
End Select

В данной конструкции работает правило: “Если значение переменной <Variable> равно значению <Significance>, то произвети список действий <Action> под этим значением, иначе перейти к проверке следующего значения <Significance>.”

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

Обычный цикл организуется структурой For – Next, в аргументах которой задаются такие параметры как имя счетчика (<Counter>), начальное значение счетчика (<Start>), конечное значение счетчика (<Finish>) и, при необходимости, шаг счетчика (Step <StepSize>).

For <Counter> = <Start> To <Finish> [Step <StepSize>]
   <Actions>
Next

Если в процессе работы цикла потребуется прекратить перебор значений, то это можно сделать с помощью команды Exit For.

For <Counter> = <Start> To <Finish>
   <Actions>
   If <Condition> Then Exit For
   <Actions>
Next

Цикл с неизвестным количеством итераций обычно применяется для перебора всех значений в коллекции объекта, когда не известна его размерность. Эта структура переберет все значения (<Variable>) массива, переданного как парамер цикла (<Array>).

For Each <Variable> In <Array>
   <Actions>
Next

Пример.

For Each oCurrentFile In oFiles
   WScript.Echo oCurrentFile.Name
Next

Циклы с условиями применяются для обработки данных, при выполнении какого-то условия. Такие циклы бывают двух видов: с проверкой в начале цикла и с проверкой в конце.

Цикл, пока выполняется условие, с проверкой в начале

Do While <Condition>
   <Action>
Loop

Цикл, пока не выполнится условие, с проверкой в начале

Do Until <Condition>
   <Action>
Loop

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

Do
   <Action>
   If <Condition> Then Exit Do
   <Action>
Loop Until <Condition>

Чтобы работать с данными и строить свои процедуры и функции, разработчки Visual Basic уже позаботились об основе сценариев – базовых функциях. VBS-скрипты функции для работы с датами, строками и числами, а так же базовые процедуры ввода-вывода и процедуры работы с сетью. Давайте вкратце рассмотрим встроенные функции.

Функции обработки дат:

Date                                                  ' возврат текущей даты;
Time                                                  ' возврат текущего времени;
Now                                                   ' возврат текущих даты и времени;
DateDiff(<Interval>, <Date1>, <Date2>)                ' возврат разницы между датами;
MonthName(<MonthNumber>)                              ' возврат названия месяца;
WeekDayName(<Day>, <Abbreviation>, <FirstDayOfWeek>)  ' возврат названия дня недели;
Day(<Date>)                                           ' возврат дня из указанной даты;
Month(<Date>)                                         ' возврат месяца из указанной даты;
Year(<Date>)                                          ' возврат года из указанной даты;
Hour(<Date>)                                          ' возврат часа из указанной даты;
Minute(<Date>)                                        ' возврат минуты из указанной даты;
Second(<Date>)                                        ' возврат секунды из указанной даты.

Функции обработки строк:

Asc(<Char>)                                   ' возврат ANSI-кода символа;
Chr(<Number>)                                 ' возврат символа по ANSI-коду;
InStr(<Line>, <Find>)                         ' возврат позиции подстроки в указанной
                                              ' строке;
InStrRev(<Line>, <Find>)                      ' возврат позиции подстроки в указанной
                                              ' строке, начиная с конца строки;
Join(<Array>, <Delimiter>)                    ' преобразование массива в строку;
Len(<Line>)                                   ' возврат длины строки;
LCase(<Line>)                                 ' преобразование строки в строку из малых
                                              ' символов;
UCase(<Line>)                                 ' преобразование строки в строку из больших
                                              ' символов;
Left(<Line>, <Number>)                        ' возврат указанного количества символов с
                                              ' начала строки;
Right(<Line>, <Number>)                       ' возврат указанного количества символов с
                                              ' конца строки;
Mid(<Line>, <StartNumber>, <Number>)          ' возврат указанного количества символов с
                                              ' указанного номера символа строки;
Replace(<Line>, <Find>, <Replace>[, Params])  ' замена подстроки в указанной строке;
Space(<Number>)                               ' строки из указанного количества пробелов;
Split(<Line>, <Delimiter>[, Params])          ' преобразование строки в массив;
String(<Number>, <Char>)                      ' строка из указанного количества
                                              ' определенных символов;
SrtReverse(<Line>)                            ' зеркальное отображение строки;
Trim(<Line>)                                  ' обрезка пробелов слева и справа от строки;
LTrim(<Line>)                                 ' обрезка пробелов слева от строки;
RTrim(<Line>)                                 ' обрезка пробелов справа от строки.

Математические функции:

Randomize         ' инициализация механизма случайных чисел (ничего не возвращает);
Rnd               ' возврат случайного нецелочисленного значения от 0 до 1;
Atn(<Number>)     ' вычисление арктангенса числа;
Cos(<Number>)     ' вычисление косинуса числа;
Sin(<Number>)     ' вычисление синуса числа;
Exp(<Number>)     ' вычисление натурального логарифма числа;
Log(<Number>)     ' вычисление десятичного логарифма числа;
Sqr(<Number>)     ' вычисление квадратного корня числа;
Abs(<Number>)     ' вычисление абсолютного значения числа;
Hex(<Number>)     ' вычисление шеснадцатеричного значения числа;
Int(<Number>)     ' округление числа;
Fix(<Number>)     ' вычисление целой части числа.

И, естественно, помимо упомянутых функций, сценарии поддерживают все простейшие математические и логические операции:

  • = – оператор присваивания;
  • – сумма двух чисел;
  • – – вычитание двух чисел;
  • * – умножение двух чисел;
  • / – деление двух чисел;
  • – целочисленное деление двух чисел;
  • Mod – остаток от деления двух чисел;
  • ^ – возведение в степень;
  • & – соединение двух строк;
  • Is – сравнение двух объектов;
  • Eqv – сравнение двух выражений;
  • Not – логическая операция отрицания;
  • And – логическая операция конъюнкции;
  • Or – логическая операция дизъюнкции;
  • Xor – логическая операция исключения;
  • Imp – логическая операция импликации.

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

Сценарии, написанные на Visual Basic, позволяют определять пользовательские процедуры и функции и вызывать их из основной программы. Между процедурой и функцией практически нет никакого различия, разница заключется в логическом смысле этих подпрограмм: функции обычно используются для вычисления какого-то значения, а процедуры – для выполнения действий. Тем не менее и процедуры, и функции могут выполнять операции и передавать значения основной программе. Несмотря на это, все же не стоит забывать о предназначении этих подпрограмм: функции – для вычисления, процедуры – для действий.

Функция объявляется оператором Function, после которого следует название пользовательской функции, которое не должно совпадать ни с одним зарезервированным словом языка Visual Basic, далее указываются переменные, которые будут передаваться подпрограмме в качестве параметров – указание переменных в этой конструкции означает выделение ячеек памяти для переменных подпрограммы (объявление переменных для функции). В теле подпрограммы структура сценария ничем не отличается от обычной программы (здесь можно объявлять дополнительные переменные, поизводить операции, использовать другие функции и процедуры), в конце тела должен присутствовать оператор присвоения функции какому-то значению – это значение и будет возвращено основной программе. Прервать выполнение функции можно оператором Exit Function, но в этом случае нужно не забыть присвоить функции какое-то значение, иначе сценарий выдаст ошибку. Завершается функция оператором End Function.

Определение функции

Function <FunctionName>([Arguments])
   <Actions>
   If <Condition> Then
       <Actions>
       <FunctionName> = <Value>
       Exit Function
   End If
   <Actions>
   <FunctionName> = <Value>
End Function

Вызов функции

<Variable> = <FunctionName>([Arguments])

Процедура определяется аналогично функции, но другим оператором -Sub. Так как процедура не возвращает основной программе никаких значений, то оператора присвоения перед выходом из процедуры нет. Прервать выполнение процедуры можно с помощью команды Exit Sub, а завершается вся конструкция оператором End Sub. Чтобы в основной программе вызвать процедуру, необходимо использовать ключевое слово Call и имя функции с необходимыми аргументами. (Ключевое словоCallне является обязательным, но я рекомендую его использовать чтобы избежать неправильных вызовов процедуры.)

Определение процедуры

Sub <SubName>([arguments])
   <Actions>
   If <Condition> Then
       <Actions>
       Exit Sub
   End If
   <Actions>
End Sub

Вызов процедуры

[Call] <SubName>([arguments])

Кстати, процедуры и функции должны располагаются в конце сценария.

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

Sub <SubName>(ByRef <Argument1>[, arguments])
	   <Actions>
	   <Argument1> = <expression>
	   <Actions>
	End Sub

В данном случае аргумент <Argument1> передается по ссылке на ячейку памяти – меняется значение переменной в основном сценарии. Иными словами, с помощью параметра ByRef процедура превращается в функцию – подпрограмма возвращает результат вычислений в основную программу.

По умолчанию все ошибки обрабатываются сценарием в автоматическом режиме, и, при возникновении ошибки, работа сценария останавливается. Для отключения автоматической обработки ошибок нужно использовать специальную директиву On Error Resume Next, которая отключает автоматическую обработку ошибок и продолжает работы сценария даже при их наличии. Для ручной обработки ошибок необходимо обратится к встроенному объектуErr, который хранит в себе статус ошибок. Объект Err имеет следующие свойства и методы:

Number          ' возврат номера последней ошибки;
Description     ' возврат описания последней ошибки;
Clear           ' очистка объекта Err;
Raise           ' вызов тестовой ошибки.

Пример ручной обработки ошибки:

On Error Resume Next
iTotalPoints = InputBox("Введите общее количество очков")
iNumberOfTests = InputBox("Введите количество тестов")
iAvarage = iTotalPoints / iNumberOfTests
Select Case Err.Number
   Case 0                            ' нет ошибок;
       WScript.Echo "Средний балл = " & CStr(iAvarage)
   Case 11                           ' деление на ноль;
       WScript.Echo "Количество тестов не может равняться нулю"
   Case 13                           ' несоотвествие типов;
       WScript.Echo "Вы ввели нечисловое значение"
   Case Else                         ' нет ошибок;
       WScript.Echo "Неизвестная ошибка
       WScript.Quit"
End Select

VBS-сценарии, как и их родитель – язык Visual Basic, является объектно-ориентированным языком программирования, то есть основной концепцией является понятие объектов и классов

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

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

Set <ObjectName> = CreateObject(<Library>.<Class>)

Удалить объект можно, присвоив ему значение Nothing:

Set <ObjectName> = Nothing

Все объекты, с которыми работает Windows Script Host, имеют методы и свойства. Чтобы обратиться к методу, необходимо указать объект, а через точку – метод с необходимыми параметрами.

<Object>.<Method> <Param1>[, Param2, ..., ParamN]
Call <Object>.<Method>(<Param1>[, Param2, ..., ParamN])

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

<Object>.<Property> = <Value>
<Object1>.<Property1> = <Object2>.<Property2>
<MyVariable> = <Object>.<Property>

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

Set oFSO = CreateObject("Scripting.FileSystemObject")
Call oFSO.CreateFolder("C:Test")
Set oFSO = Nothing

Обратите внимание, что понятие “объект” относится к логике сценария, а не к логике файловой системы. То есть, когда мы говорим “удаление объекта”, мы имеем ввиду логический объект сценария, который никак не влияет на удаление каких-то частей файловой системы.

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

  1. Запустить MS Word.
  2. В главном меню выбрать Tools -> Macro -> Visual Bacis Editor
  3. В окне редактирования макросов выбрать View -> Object Browser

Если какая-то библиотека не отражена в списке, то ее можно подключить через меню Tools -> References.

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

MsgBox(<Message>[, Params])   ' вывод оконного сообщения на экран;
InputBox(<Message>[, Params]) ' вывод диалогового окна на экран.

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

MyValue = InputBox("Введите текст", "Первое окно", "Текст нужно ввести здесь")
MyResult = MsgBox(MyValue, 1, "Второе окно")

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

CreateObject(<Library>.<Class>)    ' создание объекта;
GetObject(<FilePath>)              ' подключение объекта из файла;
ConnectObject(<Object>, <Prefix>)  ' подключение к событиям существующего объекта;
DisconnectObject(<Object>)         ' отключение от событий объекта;
Echo([Message])                    ' вывод сообщения на экран;
Arguments                          ' возврат массива аргументов командной строки сценария;
Name                               ' возврат имени интерпретатора сценариев;
Path                               ' возврат пути к интерпретатору сценариев;
FullName                           ' возврат полного имени интерпретатора сценариев;
Version                            ' возврат версии интерпретатора сценариев;
BuildVersion                       ' возврат версии сборки интерпретатора сценариев;
ScriptName                         ' возврат имени файла сценария;
ScriptFullName                     ' возврат полного имени файла сценария;
Interactive                        ' установка или возврат режима интерактивности сценария;
Sleep(<Milliseconds>)              ' приостановка работы на указанное количество миллисекунд;
Quit                               ' прекращение работы сценария.

Применение этих методов и свойств более подробно мы разберем в примерах других классов.

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

ExpandEnvironmentStrings(<VariableName>) ' возврат значения запрошенной переменной системы;
EnviEnvironment(<VariableName>)          ' возврат массива переменных системы;
CreateShortcut(<PathToCreate>)           ' создание ярлыка;
Popup(<Message>[, Params])               ' вывод оконного сообщения на экран;
RegRead(<ValuePath>)                     ' считывание значения из реестра;
RegWrite(<ValuePath>,<Value>[, Type])    ' запись значения в реестр;
RegDelete(<ValuePath>)                   ' удаление значения из реестра;
LogEvent(<Type>,<Message>)               ' запись события в системный журнал;
Run(<Command>[, Params])                 ' запуск программы в новом процессе;
Exec(<Command>)                          ' запуск программы в дочерней консоли;
AppActivate(<Title>)                     ' активация окна;
SendKeys(<Keys>)                         ' отправка символов в активное окно;
CurrentDirectory                         ' установка или возврат текущей директории;
SpecialFolders([FolderName])             ' возврат массива служебных папок или пути
	                                        ' запрошенной служебной папки.

Пример. Использование методов и свойств класса Shell.

' Создание объекта класса Shell
Set oShell = Wscript.CreateObject("WScript.Shell")
' Запуск калькулятора
oShell.Run("Calc.exe")
' Задержка
WScript.Sleep(100)
' Запуск блокнота
oShell.Run("Notepad.exe")
' Задержка
WScript.Sleep(100)
' Переключение на окно калькулятора
oShell.AppActivate "Calculator"
' Задержка
WScript.Sleep(100)
' Иммитация нажатия клавиш
oShell.SendKeys("1{ }2{=}")
' Получение пути к рабочему столу
sDesktopPath = oShell.SpecialFolders("Desktop")
' Создание объекта ярлыка
Set oLink = oShell.CreateShortcut(sDesktopPath & "Test.lnk")
' Настрока ярлыка
oLink.TargetPath = WScript.ScriptFullName
oLink.WindowStyle = 1
oLink.Hotkey = "CTRL SHIFT T"
oLink.IconLocation = "notepad.exe,0"
oLink.Description = "Test link"
oLink.WorkingDirectory = sDesktopPath
oLink.Save
' Создание объекта среды и получение в него свойств системы
Set oSysEnv = oShell.Environment("SYSTEM")
' Вывод сообщения о количестве процессоров на экран
MyResult = oShell.Popup("Number of processors: " & oSysEnv("NUMBER_OF_PROCESSORS"), _
   3, "Message", 0)
' Получение пути к папке Windows и вывод сообщения на экран
MyResult = oShell.Popup("Windows directory: " & _
   oShell.ExpandEnvironmentStrings("%WINDIR%"), 3, "Message", 0)
' Чтение ключа реестра и вывод его значения на экран
WScript.Echo oShell.RegRead ("HKLMSoftwareMicrosoftWindowsCurrentVersionProductID")
' Запись строкового значения в реестр
MyResult = oShell.RegWrite("HKCUScriptEngineValue", "My Value")
' Запись числового значения в реестр
MyResult = oShell.RegWrite("HKCUScriptEngineKey", 1, "REG_DWORD")
' Удаление ключа реестра
MyResult = oShell.RegDelete("HKCUScriptEngine")
' Запись события в системный журнал
MyResult = oShell.LogEvent(0, "Test Script Completed")

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

ComputerName                               ' возврат имени компьютера;
UserDomain                                 ' возврат имени домена;
UserName                                   ' возврат имени пользователя;
EnumNetworkDrives                          ' возврат списка подключенных сетевых дисков;
MapNetworkDrive(<LocalName>, <RemoteName>, [UpdateProfile, User, Password])
                                           ' подключение сетевого ресурса;
RemoveNetworkDrive(<Name>, [Force], [UpdateProfile])
                                           ' отключение сетевого ресурса;
EnumPrinterConnections                     ' возврат списка сетевых принтеров;
AddWindowsPrinterConnection(<PrinterPath>) ' подключение сетевого принтера;
AddPrinterConnection(<LocalName>, <RemoteName>[, UpdateProfile, User, Password]
                                           ' подключение сетевого принтера на указанный порт;
RemovePrinterConnection(<Name>[,Force, UpdateProfile])
                                           ' отключение сетевого принтера;
SetDefaultPrinter(<PrinterName>)           ' выбор принтера по умолчанию;

Пример. Использование методов и свойств класса Network.

' Создание объекта класса Network
Set oNetwork = WScript.CreateObject("WScript.Network")
' Вывод сообщения об имени компьютера
WScript.Echo "Computer Name = " & oNetwork.ComputerName
' Вывод сообщения об имени текущего пользователя
WScript.Echo "User Name = " & oNetwork.UserDomain & "" & oNetwork.UserName
' Подключение сетевого диска
oNetwork.MapNetworkDrive "Z:" "\ServerShare"
' Получение коллекции подключенных сетевых дисков
Set oDrives = oNetwork.EnumNetworkDrives
' Вывод сообщений о подключенных сетевых дисках
For i=0 To oDrives.Count -1 step 2
   WScript.Echo "Drive " & oDrives.Item(i) & " = " & oDrives.Item(i 1)
Next
' Удаление сетевого диска
oNetwork.RemoveNetworkDrive "Z:"
' Подключение сетевого принтера
oNetwork.AddPrinterConnection "LPT1", "\ServerPrinter"
' Установка принтера по умолчанию
oNetwork.SetDefaultPrinter "\ServerPrinter"
' Получение коллекции о подключенных принтерах
Set oPrinters = oNetwork.EnumPrinterConnections

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

  • FileSystemObject – главный объект, который позволяет создавать, удалять, управлять дисками, папками и файлами в общем;
  • Drive – объект, позволяюший собирать информацию о дисках системы;
  • Drives – объект, хранящий в себе список дисков системы;
  • Folder – объект, позволяющий создавать, удалять, перемещать папки, а также собирать информацию о них и их содержимом;
  • Folders – объект, хранящий в себе список подпапок указанной папки;
  • File – объект, позволяющий создавать, удалять, перемещать файлы, а также собирать информацию о них;
  • Files – объект, хранящий в себе список файлов указанной папки;
  • TextStream – объект, позволяющий читать и создавать текстовые файлы.

Методы и свойства класса FileSystemObject (главного объекта):

BuildPath(<Path>, <Name>)                          ' добавляет имя к указанному пути;
GetAbsolutePathName(<PathSpec>)                    ' возвращает полный путь;
GetBaseName(<Path>)                                ' возвращает имя папки или файла (без
                                                   ' расширения) в указанном пути;
GetDrive(<DriveSpec>)                              ' создает объект Drive;
GetDriveName(<Path>)                               ' возвращает имя диска в указанном пути;
GetExtensionName(<Path>)                           ' возвращает расширение файла в
                                                   ' указанном пути;
GetFile(<FileSpec>)                                ' создает объект File;
GetFileName(<PathSpec>)                            ' возвращает имя файла (без расширения)
                                                   ' в указанном пути;
GetFolder(<FolderSpec>)                            ' создает объект Folder;
GetParentFolderName(<Path>)                        ' возвращает имя папки в котором хранится
                                                   ' файл или папка по указанному пути;
GetSpecialFolder(<FolderSpec>)                     ' создает объект Folder к указанной
                                                   ' служебной папке;
GetTempName                                        ' возвращает случайно сгенерированное
                                                   ' имя файла;
DriveExists(<DriveSpec>)                           ' проверяет существование диска;
FolderExists(<FileSpec>)                           ' проверяет существование папки;
CopyFolder(<Source>, <Destination>[, Overwrite])   ' копирует папку;
MoveFolder(<Source>, <Destination>)                ' перемещает папку;
DeleteFolder(<FolderSpec>[, Force])                ' удаляет папку;
CreateFolder(<FolderName>)                         ' создает папку;
FileExists(<Filespec>)                             ' проверяет существование файла;
CopyFile(<Source>, <Destination>[, Overwrite])     ' копирует файл;
MoveFile(<Source>, <Destination>)                  ' перемещает файл;
DeleteFile(<FileSpec>[, Force])                    ' удаляет файл;
CreateTextFile(<FileName>[, Overwrite, UnioCode])  ' создает текстовый файл;
OpenTextFile(<FileName>[, IOMode, Create, Format]) ' открывает текстовый файл для чтения или
                                                   ' записи.

Объекты Drives, Folders и Files класса FileSystemObject хранят в себе информацию о дисках, папках и файлах и, в основном, используюся для сбора информации о файловой системе. Они имеют только два свойства:

Count                ' возвращает количество элементов в коллекции;
Item(<ObjectName>)   ' возвращает запись с указанным индексом из коллекции (не используется),
                     ' для перебора элементов коллекции приметяется цикл For Each.

Чтобы было более понятно, что же такое коллекция объектов, рассмотрим пример вывода на экран списка файлов корня диска C:

' Создание объекта класса FileSystemObject
Set oFSO = CreateObject("Scripting.FileSystemObject")
' Создание объекта Folder
Set oFolder = oFSO.GetFolder("C:")
' Получение коллекции файлов
Set oFilesCollection = oFolder.Files
' Получение количества элементов в коллекции
sResult = sResult & oFilesCollection.Count & " files in C:" & vbCrLf
' Чтение атрибутов каждого файла из коллекции
For Each oFile in oFilesCollection
   sResult = sResult & oFile.Name & vbTab
   sResult = sResult & oFile.Size & vbCrLf
Next
' Вывод результата на экран
MsgBox(sResult)

Объект Drive предоставляет доступ к свойствам локального или сетевого диска:

AvailableSpace   ' возвращает размер свободного места на диске, доступного пользователю;
DriveLetter      ' возвращает букву диска;
DriveType        ' возвращает тип диска;
FileSystem       ' возвращает тип файловой системы диска;
FreeSpace        ' возвращает размер свободного места на диске;
IsReady          ' возвращает доступность диска;
Path             ' возвращает путь к диску;
RootFolder       ' создает объект Folder, указывающий на корень диска;
SerialNumber     ' возвращает серийный номер диска;
ShareName        ' возвращает сетевое имя диска;
TotalSize        ' возвращает емкость диска в байтах;
VolumeName       ' возвращает или устанавливает метку диска.

Объект Folder предоставляет доступ ко всем свойствам папки, а также позволяет производить над ней действия:

Attributes                         ' возвращает атрибуты папки;
DateCreated                        ' возвращает дату создания папки;
DateLastAccessed                   ' возвращает дату последнего доступа к папке;
DateLastModified                   ' возвращает дату изменения папки;
Drive                              ' возвращает букву диска, на котором расположена папка;
Files                              ' возвращает коллекцию файлов папки;
IsRootFolder                       ' возвращает True, если папка - это корень диска;
Name                               ' возвращает имя папки;
ParentFolder                       ' создает объект Folder, указывающий на
                                   ' родительскую папку;
Path                               ' возвращает путь к папке;
ShortName                          ' возвращает имя папки в формате 8.3;
ShortPath                          ' возвращает путь к папке в формате 8.3;
Size                               ' возвращает размер папки;
SubFolders                         ' возвращает коллекцию подпапок;
Type                               ' возвращает тип папки;
Copy(<Destination>[, Overwrite])   ' копирует папку;
Move(<Destination>)                ' перемещает папку;
Delete(<Force>)                    ' удаляет папку;
CreateTextFile(<FileName>[, Overwrite, UniCode])
                                   ' создает в папке текстовый файл.

Объект File аналогичен объекту Folder – он предоставляет доступ ко всем свойствам файла, а также позволяет производить над ним действия:

Attributes                           ' возвращает атрибуты файла;
DateCreated                          ' возвращает дату создания файла;
DateLastAccessed                     ' возвращает дату последнего доступа к файла;
DateLastModified                     ' возвращает дату изменения файла;
Drive                                ' возвращает букву диска, на котором расположен файл;
Name                                 ' возвращает имя файла;
ParentFolder                         ' создает объект Folder, указывающий на
                                     ' родительскую папку;
Path                                 ' возвращает путь к файлу;
ShortName                            ' возвращает имя файла в формате 8.3;
ShortPath                            ' возвращает путь к файлу в формате 8.3;
Size                                 ' возвращает размер файла;
Type                                 ' возвращает тип файла;
Copy(<Destination>[, Overwrite])     ' копирует файл;
Move(<Destination>)                  ' перемещает файл;
Delete(<Force>)                      ' удаляет файл;
OpenAsTextStream([IOMode, Format])   ' открывает текстовый файл для чтения или записи.

Объект TextStream – это инструмент доступа к содержимому файла. С помощью него можно читать и изменять файл:

AtEndOfLine                ' показывает, достигнут ли конец строки;
AtEndOfStream              ' показывает, достигнут ли конец строки;
Column                     ' возвращает номер колонки, в которой находится курсор чтения;
Line                       ' возвращает номер строки, в которой находится курсор чтения;
Close                      ' закрывает файл - освобождает его для других процессов;
Read(<CharactersNumber>)   ' считывает указанное количество символов, начиная от позиции
                           ' курсора чтения;
ReadAll                    ' считывает весь файл;
ReadLine                   ' считывает строку, в которой находится курсор чтения;
Skip(<CharactersNumber>)   ' пропускает указанное количество символов, начиная от позиции
                           ' курсора чтения;
SkipLine                   ' пропускает строку, в которой находится курсор чтения;
Write(<String>)            ' записывает строку;
WriteLine(<String>)        ' записывает строку и переводит курсор записи на следующую строку;
WriteBlankLines(<Lines>)   ' записывает указанное количество пустых строк.

Мы познакомились со всеми методами и свойствами класса FileSystemObject, рассмотрим пример использования этого класса:

' Задание констант кодов системных папок
Const WindowsFolder = 0
Const SystemFolder = 1
Const TemporaryFolder = 2
' Задание констант кодов типов доступа к текстовому файлу
Const ForReading = 1
Const ForWriting = 2
Const ForAppending = 8
' Создание объекта класса FileSystemObject
Set oFSO = CreateObject("Scripting.FileSystemObject")
' Получение коллекции дисков
Set DrivesCollection = oFSO.Drives
' Обработка каждого диска для получения его метки или сетевого имени
For Each oDrive in DrivesCollection
   sResult = sResult & oDrive.DriveLetter & ": "
   If oDrive.DriveType = Remote Then
       sResult = sResult & oDrive.ShareName & vbCrLf
   ElseIf oDrive.IsReady Then
       sResult = sResult & oDrive.VolumeName & vbCrLf
   Else
       sResult = sResult & vbCrLf
   End If
Next
' Вывод результатов на экран
Wscript.Echo(sResult)
' Создание объекта диска C:
Set oDrive = oFSO.GetDrive("C")
sResult = oDrive.DriveLetter & ": - "
' Получение типа диска C:
Select Case oDrive.DriveType
   Case 0: sResult = sResult & "Unknown - "
   Case 1: sResult = sResult & "Removable - "
   Case 2: sResult = sResult & "Fixed - "
   Case 3: sResult = sResult & "Network - "
   Case 4: sResult = sResult & "CD-ROM - "
   Case 5: sResult = sResult & "RAM Disk - "
End Select
' Определение доступности диска и получение его свойств
If oDrive.IsReady Then
   sResult = sResult & "Ready" & vbCrLf
   sResult = sResult & "FileSystem is " & oDrive.FileSystem & vbCrLf
   sResult = sResult & "Available Space: " & _
     FormatNumber(oDrive.AvailableSpace/1024, 0) & " Kbytes"
Else
   sResult = sResult & "Not ready"
End If
' Вывод результатов на экран
Wscript.Echo(sResult)
' Создание объекта служебной папки (папка временных фалов Windows)
Set oTempFolder = oFSO.GetSpecialFolder(TemporaryFolder)
' Создание объекта текстового файла (и создание его в корне диска C:)
Set oFile = oFSO.CreateTextFile("C:TestFile.txt", True)
' Запись в текстовый файл
oFile.WriteLine("This is a test.")
oFile.WriteLine(sResult)
' Закрытие текстового файла и освобождение его для других процессов
oFile.Close
' Проверка на наличие файла в папке временных файлов Windows, удаление этого файла
If oFSO.FileExists(oFSo.BuildPath(oTempFolder.Path, "TestFile.txt")) Then _
 oFSO.DeleteFile(oFSo.BuildPath(oTempFolder.Path, "TestFile.txt"))
'  Создание объекта файла
Set oFile = oFSO.GetFile("C:TestFile.txt")
' Перемещение файла в папку временных файлов Windows
oFile.Move(oFSo.BuildPath(oTempFolder.Path, "TestFile.txt"))
' Изменение атрибута у файла
If oFile.Attributes and 32 Then
   oFile.Attributes = oFile.attributes - 32
   Wscript.Echo("Archive bit is cleared")
Else
   oFile.Attributes = oFile.attributes   32
   Wscript.Echo("Archive bit is set")
End If
sResult = oFile.Path & vbCrLf & oFile.DateLastModified & ":" & vbCrLf
' Создание объекта потока путем открытие файла на чтение
Set oTestFile = oFSO.OpenTextFile(oFile.Path, ForReading, False)
' Чтение потока, пока не встречен его конец
Do While oTestFile.AtEndOfStream <> True
   sResult = sResult & oTestFile.ReadLine
Loop
' Закрытие текстового файла и освобождение его для других процессов
oTestFile.Close
' Вывод сообщения на экран
Wscript.Echo(sResult)

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

' ==== Script Information Header ====
' script name:   Purge Temp
' version:       1.0
' date:          16.07.08
' autor:         Bochkarev Vitaly
' description:   Скрипт удаляет устаревшие временные файлы с компьютера

' ==== Script Main Logic ====
' Включение ручной обработки ошибок
On Error Resume Next
' Константа временного интервала, когда файлы считаются устаревшими
Const PurgeTime = 14    ' дней

' Исключения - профили пользователей, которые не должны обрабатываться
Dim aExceptions(3)
aExceptions(0) = "Default User"
aExceptions(1) = "LocalService"
aExceptions(2) = "NetworkService"
aExceptions(3) = "All Users"

' Создание объектов оболочки и файловой системы
Set oShell = CreateObject("wscript.shell")
Set oFSO = CreateObject("Scripting.Filesystemobject")

' Определение путей служебных папок
sProgramFiles = oShell.ExpandEnvironmentStrings("%ProgramFiles%")
sWinDir = oShell.ExpandEnvironmentStrings("%WinDir%")
sWinTempFolder = sWinDir & "Temp"
sDocuments = "C:Documents and Settings"

' Создание фурнала работы сценария
sLogFileName = sWinTempFolder & "PurgeTemp_" & Date
sLogFileName = Replace(sLogFileName, ".", "_")
sLogFileName = Replace(sLogFileName, "/", "_")
Set oLogFile = oFSO.CreateTextFile(sLogFileName & ".log",true)
oLogFile.WriteLine "========== Start purging =========="

' Очистка временной папки Windows
oLogFile.WriteLine vbCrLf & "========== Windows Temporary folder =========="
PurgeFolder(sWinTempFolder)

' Очистка временной папки профиля пользователя и файлов Интернет
oLogFile.WriteLine vbCrLf & _
 "========== Users Temporary folder and Users Temporary Internet Files =========="
Set oDocuments = oFSO.GetFolder(sDocuments)
Set colProfiles = oDocuments.SubFolders
For Each oProfile In colProfiles
   bFlag = false
   For Each sException in aExceptions
       if InStr(oProfile.Path,sException) > 0 then
           bFlag = true
           exit for
       end if
   Next
   If bFlag = False Then
       PurgeFolder(oProfile.Path & "Local SettingsTemp")
       PurgeFolder(oProfile.Path & "Local SettingsTemporary Internet Files")
   End If
Next

' Очистка карантина NOD32
oLogFile.WriteLine vbCrLf & "========== NOD32 Quarantine =========="
sQuarantine = sProgramFiles & "EsetInfected"
PurgeFolder(sQuarantine)

' Закрытие файла журнала
oLogFile.WriteLine vbCrLf & "========== Stop purging =========="
oLogFile.Close

' Процедура PurgeFolder - удаление старых файлов
Sub PurgeFolder(sFolderPath)
   ' Создание объекта Folder
   Set oFolder = oFSO.GetFolder(sFolderPath)
   ' Получение коллекции файлов
   Set colFiles = oFolder.Files
   ' Обработка каждого файла из коллекции
   For each oFile in colFiles
       ' Проверка, является ли файл устаревшим
       If (Date-oFile.DateLastModified) > PurgeTime and (Date-oFile.DateCreated) > _
         PurgeTime Then
           ' Запись сообщения в журнал сценария
           oLogFile.Writeline oFile.Path & vbTab & oFile.DateCreated
           ' Удаление устаревшего файла
           oFSO.DeleteFile oFile.Path, True
           ' Проверка на наличие ошибок
           if err.Number <> 0 then
               ' Запись сообщения об ошибке в журнал сценария
               oLogFile.Writeline "-----> Error # " & CStr(Err.Number) _
                 & " " & Err.Description
               ' Очистка ошибки
               Err.Clear
           end if
           ' Пауза в 20 милисекунд
           WScript.Sleep 20
       End if
   Next
   ' Получение коллекции подпапок
   Set colSubFolders = oFolder.SubFolders
   ' Обработка каждой подпапки
   For Each oSubFolder In colSubFolders
       ' Рекурсивный вызов процедуры удаления старых файлов - подпрограмма вызывает
       ' сама себя
       PurgeFolder(oSubFolder.Path)
       ' Проверка размера папки
       If oSubFolder.Size = 0 Then
           ' Запись сообщения в журнал сценария
           oLogFile.Writeline oSubFolder.Path & vbTab & oSubFolder.DateCreated
           ' Удаление пустой папки
           oFSO.DeleteFolder oSubFolder.Path
           ' Проверка на наличие ошибок
           If err.Number <> 0 then
               ' Запись сообщения об ошибке в журнал сценария
               oLogFile.Writeline "-----> Error # " & CStr(Err.Number) _
                 & " " & Err.Description
               ' Очистка ошибки
               Err.Clear
           End if
       End if
   Next
End Sub

Итак, мы познакомились с основами сценариев Visual Basic Script. Давайте подведем итог, и определим достоинства и недостатки таких сценариев:

  • сценарии не требуют компиляции и их код в любой момент можно отредактировать;
  • VBS-сценарии практически не ограничены в функциональности и могут использовать различные системные библиотеки и объекты других приложений;
  • VBS-файлы могут выполняются как в консоли, так и в оконном режиме, поэтому пользователь может контролировать видимость хода выполнения сценария;
  • VBS-сценарии позволяют использовать пользовательские процедуры и функции;
  • этот язык идеально подходит для работы со строковыми и числовыми переменными, датами, а также для обработки текстовых файлов, управления системой и доменом;
  • VBS-сценарии сложны в написании и требуют навыков программирования;
  • такие сценарии работают только в операционных системах семейства Windows.

Виталий Бочкарев

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *