Comandos para scripts vbs. VBScript. Conceptos básicos de VBScript. Métodos y propiedades de la clase raíz de WScript
Continuación
Guión visual básico
¿Por qué necesitamos scripts VBS?
El script VBS es una poderosa solución para automatizar las acciones del usuario en sistemas Windows. Este tipo de script se utiliza normalmente para:
- crear escenarios complejos;
- utilizar objetos de otras aplicaciones y bibliotecas;
- ocultar ventanas durante la ejecución del script;
- Cifrado de la lógica del script.
Los scripts VBS se utilizan principalmente para el procesamiento de datos, la gestión de sistemas, trabajar con cuentas de usuario y de computadora, interactuar con aplicaciones de oficina, trabajar con bases de datos y otras tareas complejas.
Disposiciones básicas
Dependiendo del lenguaje de escritura, el contenido y el cifrado, se encuentran los siguientes tipos de escritura:
- vbs - Guión de Visual Basic
- vbe - secuencia de comandos de Visual Basic cifrada
- js - secuencia de comandos Java
- jse: secuencia de comandos Java cifrada
- wsh - configuración del script
- wsf: script federado XML
En este artículo analizaré los scripts de tipo vbs.
Los scripts generalmente se editan en el Bloc de notas de Windows, pero recomiendo usar Notepad2, que resalta las palabras clave del lenguaje Visual Basic y ayuda a formatear el cuerpo del script. Entonces, un script vbs es un archivo de texto normal llamado *.VBS, que puede editarse fácilmente en el Bloc de notas y ejecutarse haciendo doble clic o llamando al nombre en la consola.
Como se describió anteriormente, los scripts no se compilan, sino que se interpretan. Es decir, para procesar un script, el sistema debe tener un intérprete de lenguaje VBS, e incluso hay dos intérpretes de este tipo en Windows: WScript de ventana y CScript de consola; ambos intérpretes son Windows Script Host (WSH).
De forma predeterminada, todos los scripts se ejecutan a través de WScript, es decir, no se requieren configuraciones, pero para ejecutar un script en la ventana de la consola, debe ejecutarlo a través de CScript o configurar CScript como el intérprete predeterminado. Para hacer esto, debe ejecutar lo siguiente en la línea de comando:
CScript //H:CScript
Después de lo cual todos los scripts se ejecutarán en modo consola. El regreso al modo ventana se realiza con el siguiente comando:
CScript //H:WScript
Las siguientes reglas funcionan en Visual Basic:
- la longitud de la línea no está limitada;
- Las mayúsculas y minúsculas no son sensibles;
- no se tiene en cuenta el número de espacios entre parámetros;
- la línea de comando se puede dividir y en el lugar de interrupción debe insertar el símbolo "_";
- la longitud máxima del nombre de variable es de 255 caracteres;
- Los comentarios se indican con el símbolo " " ".
" === Encabezado de información del script === " Nombre del script: " nombre del script; " Fecha: " fecha de modificación; " Autor: " autor; " Descripción: " descripción; " === Bloque de inicialización === Opción explícita " directiva , que prohíbe la creación automática de " variables; Oscuro
variables
De forma predeterminada, las variables en los scripts se declaran automáticamente la primera vez que se usan en el cuerpo del script, a menos que lo prohíba la directiva Option Explicit. Si declara la directiva Option Explicit al comienzo del script, todas las variables deben definirse de antemano utilizando las siguientes construcciones:
Oscuro
Las constantes se declaran al principio del script utilizando la siguiente construcción:
constante
El tipo de variable se asigna automáticamente después de ingresar el primer valor. Los siguientes tipos de datos existen en Visual Basic:
- vacío - variable no inicializada;
- nulo - variable vacía;
- booleano: tipo lógico, valores posibles: Falso, Verdadero o 0, 1;
- byte: entero sin signo de 8 bits, valores posibles: 0 .. 255;
- entero - entero de 32 bits, valores posibles: -32768 .. 32767;
- long: entero de 64 bits, valores posibles: -2147483648 .. 2147483647;
- moneda - tipo monetario, valores posibles: -922337203685477.5808 a 922337203685477.5807;
- único - número de punto flotante, valores posibles: -3.402823e38 .. -1.401298e-45 para números negativos y 1.401298e-45 .. 3.402823e38 para números positivos;
- doble - número de punto flotante, valores posibles: 1.79769313486232e308 .. -4.94065645841247e-324 para números negativos y 4.94065645841247e-324 .. 1.79769313486232e308 para números positivos;
- fecha - fecha, valores posibles: 01/01/1900 y 31/01/9999;
- string - variable de cadena, capacidad de hasta 2 mil millones de caracteres;
- objeto: puntero a un objeto;
- error - código de error.
Se puede verificar que los datos cumplan con el tipo, así como convertirlos de un tipo a otro, si los valores lo permiten. Los siguientes comandos se utilizan para operaciones con tipos de datos:
TipoVar(
Como se mencionó anteriormente, Visual Basic no impone restricciones estrictas sobre los nombres de las variables, pero al mismo tiempo, existen pautas para los nombres de las variables para que el tipo de datos pueda identificarse fácilmente en el texto del script. Para ello, se recomienda anteponer el nombre de la variable con símbolos condicionales que determinan el tipo de variable:
- iValueName - tipos numéricos
- sValueName - tipo de cadena
- bValueName - tipo booleano
- dValueName - fecha
- oValueName - objeto
- cValueName - constante
- aArrayName - matriz
En los scripts VBS, es posible utilizar matrices de variables que le permiten almacenar listas, tablas e incluso estructuras más complejas. Las matrices unidimensionales (listas) pueden ser dinámicas, es decir, permiten que su dimensión cambie a medida que se ejecuta el script. Todas las matrices se declaran con el comando Dim:
Oscuro
Ejemplo de uso de matrices
Dim aMyArray1(10,10) " crea una matriz estática de tamaño 11x11; Dim aMyArray2() " crea una matriz dinámica; aMyArray1(0,0) = "Hola" " llenando la matriz; aMyArray1(0,1) = "Personas" " llenando la matriz; aMyArray1(1,0) = "Mundo" " llenando la matriz.
Antes de usar una matriz dinámica, debe indicar la dimensión actual usando el comando ReDim, después de lo cual la matriz se puede reformatear en cualquier parte del script, ya sea borrando toda la matriz o guardando los valores de celda antiguos con el comando Conservar:
ReDim aMyArray2(0) " formando una matriz a partir de un elemento; aMyArray2(0) = "Hola" " llenando la matriz; ReDim aMyArray2(1) " eliminando la matriz antigua y formando una nueva a partir de " otros elementos; aMyArray2(0) = "Hola" " llenando la matriz; aMyArray2(1) = "Mundo" " llenando la matriz; ReDim Preserve aMyArray2(2)" formando un array de tres elementos, dejando " los valores antiguos de los elementos en las celdas donde estaban; aMyArray2(1) = "!" "llenando una matriz; Erase aMyArray2" eliminando una matriz.
Para conocer la dimensión de una matriz, generalmente usan la función UBound, que se discutirá a continuación junto con otras funciones para trabajar con datos.
Ramificación por condición
Ningún escenario completo está completo sin que las ramas ayuden a elegir el camino correcto cuando se cumple o no alguna condición subyacente. En otras palabras, las ramas implementan la lógica del script. Los scripts VBS implementan varios mecanismos de ramificación. Veámoslos en orden.
Construcción para una acción realizada según una condición:
Si
Un diseño para varias acciones realizadas en función de una condición:
Si
Diseño de horquilla:
Si
Construcción "bifurcación en varios caminos" (opción cIf):
Si
En todas las construcciones anteriores, se aplica la siguiente regla: “Si se cumple la condición
Construcción "bifurcación en varios caminos" (opción con Seleccionar):
Seleccionar caso
La siguiente regla funciona en esta construcción: “Si el valor de una variable
Ciclos
Los bucles se utilizan generalmente para organizar acciones repetidas o iterar a través de elementos de una matriz. En los scripts VBS, se organizan varios tipos de bucles: un bucle normal, un bucle con un número desconocido de iteraciones y un bucle condicional.
Un bucle normal está organizado por la estructura For - Next, cuyos argumentos especifican parámetros como el nombre del contador (
Para
Si necesita dejar de iterar sobre los valores mientras se ejecuta el bucle, puede hacerlo usando el comando Salir para
Para
Un bucle con un número desconocido de iteraciones se suele utilizar para recorrer todos los valores de una colección de un objeto cuando se desconoce su dimensión. Esta estructura iterará sobre todos los valores (
Para cada uno
Para cada oCurrentFile en oFiles WScript.Echo oCurrentFile.Name Siguiente
Los bucles condicionales se utilizan para procesar datos cuando se cumple alguna condición. Hay dos tipos de bucles de este tipo: con verificación al comienzo del ciclo y con verificación al final.
Repita hasta que se cumpla la condición, comprobando al principio
hacer mientras
Repita hasta que se cumpla la condición, comprobando al principio
hacer hasta
Como se mencionó anteriormente, las condiciones se pueden colocar al final del ciclo. En este caso, el cuerpo del bucle se ejecutará al menos una vez. Al igual que en los bucles normales, un bucle con una condición se puede interrumpir con el comando Exit Do:
Hacer
Funciones integradas
Para trabajar con datos y crear sus propios procedimientos y funciones, los desarrolladores de Visual Basic ya se han ocupado de la base de los scripts: las funciones básicas. Funciones de scripts VBS para trabajar con fechas, cadenas y números, así como procedimientos básicos de entrada y salida y procedimientos de red. Echemos un vistazo rápido a las funciones integradas.
Funciones de procesamiento de fechas:
Fecha "devuelve la fecha actual; Hora" devuelve la hora actual; Ahora "devuelve la fecha y hora actuales; DateDiff(
Funciones de procesamiento de cadenas:
Asc(
Funciones matemáticas:
Randomize " inicializa el motor de números aleatorios (no devuelve nada); Rnd " devuelve un valor aleatorio no entero de 0 a 1; Atn(
Y, por supuesto, además de las funciones mencionadas, los scripts admiten todas las operaciones matemáticas y lógicas más simples:
- = - operador de asignación;
- + - la suma de dos números;
- - - resta de dos números;
- * - multiplicación de dos números;
- / - división de dos números;
- \ - división entera de dos números;
- Mod - resto de la división de dos números;
- ^ - exponenciación;
- & - concatenación de dos cadenas;
- Es - comparación de dos objetos;
- Eqv - comparación de dos expresiones;
- No - operación de negación lógica;
- Y - operación de conjunción lógica;
- O - operación lógica de disyunción;
- Xor - operación de exclusión lógica;
- Imp es la operación lógica de implicación.
El orden de las operaciones se determina como en todos los lenguajes de programación: primero se realizan las operaciones entre paréntesis, luego se calculan las funciones, luego las operaciones de multiplicación y división, seguido de la suma y la resta, y las operaciones lógicas completan el cálculo.
Funciones personalizadas
Los scripts escritos en Visual Basic le permiten definir procedimientos y funciones personalizados y llamarlos desde el programa principal. Prácticamente no existe diferencia entre un procedimiento y una función, la diferencia radica en el significado lógico de estas rutinas: las funciones se suelen utilizar para calcular algún valor y los procedimientos, para realizar acciones. Sin embargo, tanto los procedimientos como las funciones pueden realizar operaciones y pasar valores al programa principal. A pesar de esto, no debemos olvidarnos del propósito de estas subrutinas: funciones para cálculos, procedimientos para acciones.
La función es declarada por el operador Función, seguido del nombre de la función definida por el usuario, el cual no debe coincidir con ninguna palabra reservada del lenguaje Visual Basic, luego se indican las variables que serán pasadas a la subrutina como parámetros - especificando variables en esta construcción significa asignar celdas de memoria para las variables de subrutina (variables de declaración para la función). En el cuerpo del subprograma, la estructura del script no es diferente de la de un programa normal (aquí puede declarar variables adicionales, realizar operaciones, utilizar otras funciones y procedimientos, al final del cuerpo debe haber un operador que asigne un); función a algún valor: este valor se devolverá al programa principal. Puede interrumpir la ejecución de una función utilizando la instrucción Exit Function, pero en este caso debe recordar asignar algún valor a la función; de lo contrario, el script arrojará un error. La función finaliza con la instrucción End Function.
Definición de función
Función
Llamar a una función
Un procedimiento se define de manera similar a una función, pero con un operador -Sub diferente. Dado que el procedimiento no devuelve ningún valor al programa principal, no existe una declaración de asignación antes de salir del procedimiento. Puede interrumpir la ejecución del procedimiento utilizando el comando Salir Sub, y toda la construcción finaliza con el operador End Sub. Para llamar a un procedimiento en el programa principal, debe utilizar la palabra clave Llamar y el nombre de la función con los argumentos necesarios. (La palabra clave Call es opcional, pero recomiendo usarla para evitar llamadas a procedimientos incorrectos).
Definición del procedimiento
Sub
Llamar a un procedimiento
Por cierto, los procedimientos y funciones deben ubicarse al final del script.
Mientras se ejecuta la subrutina, los valores de las variables en la parte principal del script no cambian, incluso si la subrutina contiene variables con el mismo nombre. Para que la subrutina pueda cambiar los valores de las variables principales del script, es necesario establecer la propiedad de la variable como ByRef en los argumentos de la subrutina. De forma predeterminada, todas las variables se definen con la propiedad ByVal.
Sub
En este caso el argumento
Manejo de errores de ejecución de scripts
De forma predeterminada, el script procesa todos los errores automáticamente y, si se produce un error, el script deja de ejecutarse. Para deshabilitar el manejo automático de errores, debe usar la directiva especial On Error Resume Next, que deshabilita el manejo automático de errores y continúa el script incluso si hay errores. Para manejar errores manualmente, debe acceder al objeto Err incorporado, que almacena el estado del error. El objeto Err tiene las siguientes propiedades y métodos:
Número " devuelve el número del último error; Descripción " devuelve la descripción del último error; Borrar "borrar el objeto Err; Raise" llamando a un error de prueba.
Ejemplo de manejo manual de errores:
En caso de error, reanudar siguiente iTotalPoints = InputBox("Ingrese el número total de puntos") iNumberOfTests = InputBox("Ingrese el número de pruebas") iAvarage = iTotalPoints / iNumberOfTests Seleccione Caso Err.Number Caso 0 " sin errores; WScript.Echo "Promedio puntuación = " & CStr(iAvarage) Caso 11 " división por cero;
WScript.Echo "El número de pruebas no puede ser cero" Caso 13 "no coincide el tipo; WScript.Echo "Ingresó un valor no numérico "Case De lo contrario" no hay errores;
WScript.Echo "Error desconocido WScript.Quit" Seleccionar fin
Objetos, sus métodos y propiedades.
Los scripts VBS, al igual que su padre Visual Basic, son un lenguaje de programación orientado a objetos, es decir, el concepto principal es el concepto de objetos y clases.
Una clase es un tipo que describe la estructura de los objetos. Un objeto significa algo que tiene un determinado comportamiento y forma de representación; un objeto es una instancia de una clase. Una clase se puede comparar con un modelo según el cual se crean los objetos. Normalmente, las clases se diseñan de tal manera que sus objetos correspondan a los objetos del dominio.
Colocar
Una clase es un tipo que describe la estructura de los objetos. Un objeto significa algo que tiene un determinado comportamiento y forma de representación; un objeto es una instancia de una clase. Una clase se puede comparar con un modelo según el cual se crean los objetos. Normalmente, las clases se diseñan de tal manera que sus objetos correspondan a los objetos del dominio.
Puedes eliminar un objeto asignándole el valor Nada:
[, Param2, ..., ParamN] Llamar
Ejemplo. Crear un objeto del sistema de archivos, llamar al método de creación de carpetas y eliminar el objeto. Establecer oFSO = CreateObject("Scripting.FileSystemObject") Llamar a oFSO.CreateFolder("C:\Test") Establecer oFSO = Nada Tenga en cuenta que el término "objeto" se refiere a la lógica del script, no a la lógica del sistema de archivos. Es decir, cuando decimos "eliminar un objeto", nos referimos a un objeto de script lógico que no afecta de ninguna manera la eliminación de ninguna parte del sistema de archivos. Para saber qué bibliotecas existen en su sistema operativo, las clases incluidas en las bibliotecas, sus métodos y propiedades, puede utilizar el explorador de objetos, por ejemplo de Microsoft Word: Si una biblioteca no se refleja en la lista, se puede conectar a través del menú Herramientas -> Referencias. Los scripts tienen métodos que no forman parte de ninguna clase; están disponibles directamente en el cuerpo del script: cuadro de mensajes( Un ejemplo de cómo mostrar un cuadro de diálogo solicitando texto y luego mostrar un mensaje en la ventana con el texto ingresado. MyValue = InputBox("Ingrese texto", "Primera ventana", "El texto debe ingresarse aquí") MyResult = MsgBox(MyValue, 1, "Segunda ventana") Los métodos y propiedades de la clase raíz de WScript no requieren la creación de un objeto; están automáticamente disponibles para su uso directamente en el cuerpo del script. CrearObjeto( Discutiremos el uso de estos métodos y propiedades con más detalle en ejemplos de otras clases. Para trabajar con el sistema operativo, se utiliza una clase Shell especial, que le permite realizar operaciones como iniciar programas, cambiar el registro, crear accesos directos, acceder a carpetas y variables del sistema y acceder al registro del sistema. Entonces, los métodos y propiedades de la clase Shell: ExpandirEnvironmentStrings( Ejemplo. Usando métodos y propiedades de la clase Shell. " Creando un objeto de la clase Shell Set oShell = Wscript.CreateObject("WScript.Shell") " Ejecutando la calculadora oShell.Run("Calc.exe") " Retraso WScript.Sleep(100) " Ejecutando el bloc de notas oShell.Run ("Notepad.exe ") " Delay WScript.Sleep(100) " Cambiar a la ventana de la calculadora oShell.AppActivate "Calculator" " Delay WScript.Sleep(100) " Simular pulsaciones de teclas oShell.SendKeys("1(+)2(= )") " Recibir ruta al escritorio sDesktopPath = oShell.SpecialFolders("Desktop") " Crear un objeto de acceso directo Establecer oLink = oShell.CreateShortcut(sDesktopPath & "\Test.lnk") " Configurar un acceso directo oLink.TargetPath = WScript .ScriptFullName oLink.WindowStyle = 1 oLink .Hotkey = "CTRL+SHIFT+T" oLink.IconLocation = "notepad.exe,0" oLink.Description = "Enlace de prueba" oLink.WorkingDirectory = sDesktopPath oLink.Save " Creando un objeto de entorno y obtener las propiedades del sistema Set oSysEnv = oShell.Environment("SYSTEM") " Mostrar un mensaje sobre la cantidad de procesadores en la pantalla MyResult = oShell.Popup("Número de procesadores: " & oSysEnv("NUMBER_OF_PROCESSORS"), _ 3, "Mensaje", 0) "Obtiene la ruta de la carpeta de Windows y muestra un mensaje en la pantalla MyResult = oShell.Popup("directorio de Windows: " & _ oShell.ExpandEnvironmentStrings("%WINDIR%"), 3, "Mensaje" , 0) " Leer una clave de registro y mostrar su valor en la pantalla WScript. Echo oShell.RegRead("HKLM\Software\Microsoft\Windows\CurrentVersion\ProductID") " Escribe un valor de cadena en el registro MyResult = oShell.RegWrite( "HKCU\ScriptEngine\Value", "My Value") " Escribe un valor numérico en el registro MyResult = oShell.RegWrite("HKCU\ScriptEngine\Key", 1, "REG_DWORD") " Eliminación de una clave de registro MyResult = oShell. RegDelete("HKCU\ScriptEngine\") " Escribir un evento en el registro del sistema MyResult = oShell.LogEvent(0, "Script de prueba completado") Como ya hemos visto, los scripts VBS pueden funcionar con el shell de Windows, pero ésta no es su única capacidad. Con la clase Red, puede acceder y administrar objetos de red. Echemos un vistazo más de cerca a la clase Red: ComputerName "devuelve el nombre de la computadora; UserDomain" devuelve el nombre de dominio; UserName " devuelve el nombre de usuario; EnumNetworkDrives " devuelve una lista de unidades de red asignadas; MapNetworkDrive( Ejemplo. Utilizando métodos y propiedades de la clase Network. " Creando un objeto de la clase Network Set oNetwork = WScript.CreateObject("WScript.Network") " Mostrando un mensaje sobre el nombre de la computadora WScript.Echo "Computer Name = " & oNetwork.ComputerName " Mostrando un mensaje sobre el nombre de la usuario actual WScript.Echo "User Name = " & oNetwork.UserDomain & "\" & oNetwork.UserName " Asignación de una unidad de red oNetwork.MapNetworkDrive "Z:" "\\Server\Share" " Obtención de una colección de unidades de red asignadas Establecer oDrives = oNetwork.EnumNetworkDrives " Mostrando mensajes sobre unidades de red asignadas Para i=0 A oDrives.Count -1 paso 2 WScript.Echo "Drive " & oDrives.Item(i) & " = " & oDrives.Item(i+1) Siguiente " Quitar una unidad de red oNetwork.RemoveNetworkDrive "Z:" " Conectar una impresora de red oNetwork.AddPrinterConnection "LPT1", "\\Server\Printer" " Configurar la impresora predeterminada oNetwork.SetDefaultPrinter "\\Server\Printer" " Obtener una colección de impresoras conectadas Establecer oPrinters = oNetwork.EnumPrinterConnections Muy a menudo, en escenarios, hay casos en los que es necesario crear, eliminar, mover o cambiar algo en el disco de la computadora. Este problema puede resolverse mediante la clase FileSystemObject, diseñada para funcionar con el sistema de archivos. Los siguientes son los objetos que esta clase puede crear: Métodos y propiedades de la clase FileSystemObject (objeto principal): Ruta de construcción ( Los objetos Unidades, Carpetas y Archivos de la clase FileSystemObject almacenan información sobre unidades, carpetas y archivos y se utilizan principalmente para recopilar información sobre el sistema de archivos. Tienen sólo dos propiedades: Count " devuelve el número de elementos de la colección; Item( Para dejar más claro qué es una colección de objetos, considere un ejemplo de visualización de una lista de archivos en la raíz de la unidad C: " Crear un objeto de la clase FileSystemObject Set oFSO = CreateObject("Scripting.FileSystemObject") " Crear una carpeta Establecer objeto oFolder = oFSO.GetFolder("C:\") " Obtener una colección de archivos Set oFilesCollection = oFolder.Files " Obtener el número de elementos en la colección sResult = sResult & oFilesCollection.Count & " files in C:\" & vbCrLf " Leer los atributos de cada archivo de la colección para cada oFile en oFilesCollection sResult = sResult & oFile.Name & vbTab sResult = sResult & oFile.Size & vbCrLf Next "Envía el resultado a la pantalla MsgBox(sResult) El objeto Drive proporciona acceso a las propiedades de una unidad local o de red: AvailableSpace " devuelve la cantidad de espacio libre en disco disponible para el usuario; DriveLetter " devuelve la letra de la unidad; DriveType " devuelve el tipo de unidad; FileSystem " devuelve el tipo de sistema de archivos de la unidad; FreeSpace " devuelve la cantidad de espacio libre en disco; IsReady " devuelve la disponibilidad del disco; Path " devuelve la ruta al disco; RootFolder " crea un objeto Carpeta que apunta a la raíz del disco; SerialNumber " devuelve el número de serie del disco; ShareName " devuelve el nombre de red del disco; TotalSize " devuelve la capacidad del disco en bytes; VolumeName " devuelve o establece la etiqueta del disco. El objeto Carpeta proporciona acceso a todas las propiedades de una carpeta y también le permite realizar acciones en ella: Atributos " devuelve los atributos de la carpeta; FechaCreada " devuelve la fecha de creación de la carpeta; DateLastAccessed " devuelve la fecha en que se accedió a la carpeta por última vez; DateLastModified " devuelve la fecha en que se modificó la carpeta; Unidad " devuelve la letra de unidad de la carpeta; Archivos " devuelve la colección de archivos de la carpeta; IsRootFolder " devuelve True si la carpeta es la raíz del disco; Nombre " devuelve el nombre de la carpeta; ParentFolder " crea un objeto Carpeta que apunta a " la carpeta principal; Ruta " devuelve la ruta de la carpeta; Nombre Corto " devuelve el nombre de la carpeta en formato 8.3; ShortPath " devuelve la ruta a la carpeta en formato 8.3; Tamaño " devuelve el tamaño de la carpeta; SubCarpetas " devuelve una colección de subcarpetas; Tipo " devuelve el tipo de carpeta; Copiar( El objeto Archivo es similar al objeto Carpeta: proporciona acceso a todas las propiedades del archivo y también le permite realizar acciones en él: Atributos " devuelve los atributos del archivo; FechaCreada " devuelve la fecha de creación del archivo; DateLastAccessed " devuelve la fecha en que se accedió al archivo por última vez; DateLastModified " devuelve la fecha en que se modificó el archivo; Unidad " devuelve la letra de la unidad del archivo; Nombre " devuelve el nombre del archivo; ParentFolder " crea un objeto Carpeta que apunta a " la carpeta principal; Ruta " devuelve la ruta al archivo; Nombre Corto " devuelve el nombre del archivo en formato 8.3; ShortPath " devuelve la ruta al archivo en formato 8.3; Tamaño " devuelve el tamaño del archivo; Escriba " devuelve el tipo de archivo; Copiar( El objeto TextStream es una herramienta para acceder al contenido de un archivo. Puedes usarlo para leer y modificar un archivo: AtEndOfLine " muestra si se ha llegado al final de la línea; AtEndOfStream " muestra si se ha llegado al final de la línea; Columna " devuelve el número de la columna en la que se encuentra el cursor de lectura; Línea " devuelve el número de la línea en la que se encuentra el cursor de lectura; Cerrar " cierra el archivo - lo libera para otros procesos; Leer( Nos familiarizamos con todos los métodos y propiedades de la clase FileSystemObject, veamos un ejemplo del uso de esta clase: " Configurar códigos constantes para carpetas del sistema Const WindowsFolder = 0 Const SystemFolder = 1 Const TemporaryFolder = 2 " Configurar códigos constantes para tipos de acceso a un archivo de texto Const ForReading = 1 Const ForWriting = 2 Const ForAppending = 8 " Crear un objeto de la clase FileSystemObject Set oFSO = CreateObject(" Scripting.FileSystemObject") " Recuperar una colección de unidades Set DrivesCollection = oFSO.Drives " Procesar cada unidad para obtener su etiqueta o nombre de red Para cada oDrive en DrivesCollection sResult = sResult & oDrive.DriveLetter & ": " Si 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 " Mostrando los resultados Wscript.Echo(sResult) " Crear un objeto de unidad C: Establecer oDrive = oFSO.GetDrive("C") sResult = oDrive.DriveLetter & ": - " " Obtener el tipo de unidad C: Seleccionar caso oDrive.DriveType Caso 0: sResult = sResult & "Desconocido - " Caso 1: sResult = sResult & "Removable - " Caso 2: sResult = sResult & "Fixed - " Caso 3: sResult = sResult & "Red - " Caso 4: sResult = sResult & "CD-ROM - " Caso 5: sResult = sResult & "Disco RAM - " End Select " Determina si un disco está disponible y obtiene sus propiedades. Si oDrive.IsReady Entonces sResult = sResult & "Ready" & vbCrLf sResult = sResult & "FileSystem is " & oDrive.FileSystem & vbCrLf sResult = sResult & "Espacio disponible: " & _ FormatNumber( oDrive.AvailableSpace/1024, 0) & " Kbytes" Else sResult = sResult & "No listo" End If " Mostrando resultados en la pantalla Wscript.Echo(sResult) " Creando un servicio objeto de carpeta (carpeta de archivos temporales de Windows) Set oTempFolder = oFSO. GetSpecialFolder(TemporaryFolder) " Cree un objeto de archivo de texto (y créelo en la raíz de la unidad C:) Set oFile = oFSO.CreateTextFile("C:\TestFile.txt ", True) " Escribe en un archivo de texto oFile.WriteLine("Esto es una prueba.") oFile.WriteLine(sResult) " Cierra un archivo de texto y lo libera para otros procesos oFile.Close " Comprueba la presencia de un archivo en la carpeta de archivos temporales de Windows, elimina el archivo If oFSO.FileExists(oFSo.BuildPath(oTempFolder.Path, "TestFile.txt")) Entonces _ oFSO.DeleteFile(oFSo.BuildPath(oTempFolder.Path, "TestFile.txt") ) " Crear un objeto de archivo Set oFile = oFSO.GetFile("C:\TestFile.txt") " Mover el archivo a la carpeta de archivos temporales de Windows oFile.Move(oFSo.BuildPath(oTempFolder.Path, "TestFile.txt")) " Cambiando el atributo del archivo Si oFile.Attributes y 32 Luego oFile. Atributos = oFile.attributes - 32 Wscript.Echo("El bit de archivo se borra") Else oFile.Attributes = oFile.attributes + 32 Wscript.Echo("El bit de archivo está establecido") End If sResult = oFile.Path & vbCrLf & oFile .DateLastModified & ":" & vbCrLf " Crea un objeto de secuencia abriendo un archivo para leer Set oTestFile = oFSO.OpenTextFile(oFile.Path, ForReading, False) " Lee una secuencia hasta encontrar su final Do While oTestFile.AtEndOfStream<>True sResult = sResult & oTestFile.ReadLine Loop " Cierra un archivo de texto y lo libera para otros procesos oTestFile.Close " Imprime un mensaje en la pantalla Wscript.Echo(sResult) Este script está diseñado para limpiar el sistema de archivos obsoletos en directorios temporales y perfiles de usuario de Windows. En este ejemplo, puede ver cómo funcionan casi todas las construcciones anteriores: estructura del script, denominación de variables, trabajo con matrices y colecciones, manejo manual de errores, lectura de variables del sistema, creación de un archivo de texto para registrar el script, trabajo con el sistema de archivos. , utilizando procedimientos. " ==== Encabezado de información del script ==== " nombre del script: Purge Temp " versión: 1.0 " fecha: 16/07/08 " autor: Bochkarev Vitaly " descripción: El script elimina archivos temporales obsoletos de la computadora " == == Lógica principal del script ==== " Habilitar el manejo manual de errores al reanudar con error Siguiente " Intervalo de tiempo constante cuando los archivos se consideran obsoletos Const PurgeTime = 14 " días " Excepciones: perfiles de usuario que no deben procesarse Dim aExceptions(3) aExceptions( 0) = "Usuario predeterminado" aExceptions(1) = "LocalService" aExceptions(2) = "NetworkService" aExceptions(3) = "Todos los usuarios" " Creación de objetos de shell y sistema de archivos Set oShell = CreateObject("wscript.shell") Set oFSO = CreateObject ("Scripting.Filesystemobject") " Definición de rutas de carpetas de servicio sProgramFiles = oShell.ExpandEnvironmentStrings("%ProgramFiles%") sWinDir = oShell.ExpandEnvironmentStrings("%WinDir%") sWinTempFolder = sWinDir & "\Temp" sDocuments = "C:\ Documents and Settings" " Creación de un archivo de registro de script sLogFileName = sWinTempFolder & "\PurgeTemp_" & Date sLogFileName = Reemplazar(sLogFileName, ".", "_") sLogFileName = Reemplazar(sLogFileName, "/", "_ ") Establecer oLogFile = oFSO.CreateTextFile(sLogFileName & ".log",true) oLogFile.WriteLine "========== Iniciar la purga ==========" " Limpiar Windows carpeta temporal oLogFile.WriteLine vbCrLf & "========== Carpeta temporal de Windows ==========" PurgeFolder(sWinTempFolder) " Limpieza de la carpeta temporal del perfil de usuario y archivos de Internet oLogFile. WriteLine vbCrLf & _ "===== ===== Carpeta temporal de usuarios y Archivos temporales de Internet de usuarios ==========" Establecer oDocuments = oFSO.GetFolder(sDocuments) Establecer colProfiles = oDocuments.SubFolders para Cada oProfile en colProfiles bFlag = false Para cada sException en aExceptions si InStr(oProfile.Path,sException) > 0 entonces bFlag = true salir para finalizar si Next Si bFlag = False Entonces PurgeFolder(oProfile.Path & "\Local Settings\Temp" ) PurgeFolder(oProfile.Path & "\Configuración local\Archivos temporales de Internet") Finalizar si es siguiente " Borrar la cuarentena de NOD32 oLogFile.WriteLine vbCrLf & "========== Cuarentena de NOD32 ======== ==" sQuarantine = sProgramFiles & "\Eset \Infected" PurgeFolder(sQuarantine) " Cerrando el archivo de registro oLogFile.WriteLine vbCrLf & "========== Detener la purga ========== " oLogFile.Close " Procedimiento PurgeFolder: eliminación de archivos antiguos Sub PurgeFolder(sFolderPath) " Creación de una carpeta Establecer objeto oFolder = oFSO.GetFolder(sFolderPath) " Recuperar una colección de archivos Establecer colFiles = oFolder. Archivos " Procese cada archivo de la colección Para cada oFile en colFiles " Compruebe si el archivo está desactualizado Si (Date-oFile.DateLastModified) > PurgeTime y (Date-oFile.DateCreated) > _ PurgeTime Luego " Escriba un mensaje al registro de script oLogFile.Writeline oFile.Path & vbTab & oFile.DateCreated " Eliminación de un archivo obsoleto oFSO.DeleteFile oFile.Path, True " Comprobando errores si err.Number<>0 y luego " Escriba un mensaje de error en el registro del script oLogFile.Writeline "-----> Error # " & CStr(Err.Number) _ & " " & Err.Description " Borre el error Err.Clear finalice si " Pausa 20 milisegundos WScript.Sleep 20 End if Next " Recibir una colección de subcarpetas Set colSubFolders = oFolder.SubFolders " Procesar cada subcarpeta para cada oSubFolder en colSubFolders " Llamar recursivamente al procedimiento para eliminar archivos antiguos; la subrutina llama a " ella misma PurgeFolder(oSubFolder.Path ) " Comprobar el tamaño de la carpeta Si oSubFolder.Size = 0 Entonces " Escriba un mensaje en el registro del script oLogFile.Writeline oSubFolder.Path & vbTab & oSubFolder.DateCreated " Eliminar una carpeta vacía oFSO.DeleteFolder oSubFolder.Path " Compruebe si hay errores Si es err .Número<>0 y luego " Escriba un mensaje de error en el registro del script oLogFile.Writeline "-----> Error # " & CStr(Err.Number) _ & " " & Err.Description " Borre el error Err.Clear End if End if Siguiente final sub Hasta ahora hemos aprendido los conceptos básicos de Visual Basic Script. Resumamos y determinemos las ventajas y desventajas de tales escenarios: Vitali Bochkarev Sección de enlaces externos, es decir, enlaces a otros sitios con los que este recurso no tiene relación. Además, el propietario del sitio no asume ninguna responsabilidad por la disponibilidad de estos recursos y su contenido. De alguna manera me adelanté por completo y no te hablé de dos Funciones del cuadro de diálogo: MsgBox y InputBox. En esta muy breve lección te hablaré de todos los gadgets para estas dos funciones. También hay otras formas de crear cuadros de diálogo, pero esto requerirá Objetos WSH, que se discutirá en las siguientes lecciones. La función más común para mostrar un mensaje. Por supuesto que es más complicado que Hacer eco de un objeto WScript, pero ella tampoco necesita el objeto. Parámetro Botones puede tomar simultáneamente varios valores. Para indicarlos utilice el signo “+” o simplemente utilice la suma de los valores. Los valores de este parámetro se dan a continuación. Vale la pena señalar que el parámetro Botones No se pueden aceptar múltiples valores de la misma categoría. Estos valores simplemente se sumarán. Es decir, no podrás instalar varios conjuntos de botones o iconos al mismo tiempo. "Lección VBScript nº 16: "Función MsgBox y InputBox "file_1.vbs"********************************* * ********************** MsgBox "Hola", 5+16, "Título" MsgBox "Hola", vbRetryCancel+16, "Título" MsgBox "Hola" " , vbRetryCancel+524288, "Título" MsgBox "Hola", vbAbortRetryIgnore + vbInformation + vbDefaultButton2 + vbSystemModal + 524288, "Título" MsgBox "Hola", 528706, "Título" "********************************************************
"Lección de VBScript n.º 16: "Función MsgBox y InputBox "archivo_1.vbs "********************************************************
MsgBox "Hola", 5 + 16, "Título" MsgBox "Hola", vbRetryCancel + 16, "Título" MsgBox "Hola", vbRetryCancel + 524288, "Título" MsgBox "Hola", vbAbortRetryIgnore + vbInformation + vbDefaultButton2 + vbSystemModal + 524288, "Título" MsgBox "Hola", 528706, "Título" Además, la función MsgBox puede devolver el resultado de los clics en los botones. Se puede asignar a una variable y de esta manera determinar el botón presionado. "*************************************************** ******* "Lección n.º 16 de VBScript: "Función MsgBox y InputBox "file_2.vbs"************************** *********** ***************************** Dim Knopka Knopka = MsgBox("Presione cualquier botón ",2,"Título") Si Knopka = 3 Entonces MsgBox "Presionaste el botón - Abortar" ElseIf Botón = 4 Luego MsgBox "Presionaste el botón - Repetir" De lo contrario MsgBox "Presionaste el botón - Omitir" Fin si "*************************************************** ******* "Lección n.º 16 de VBScript: "Función MsgBox y InputBox "file_4.vbs"************************** *********** ******************************* Dim Dict, AboutBomb Set Dict = CreateObject(" Scripting.Dictionary") Dict.CompareMode = 1 Dict .Add "Amarillo", "¡La bomba ha explotado!" Dict.Add "Rojo", "¡Has desactivado la bomba!" Dict.Add "Azul", "La bomba ha explotó!" InputBox("¡¡¡Bomba detectada!!! ¿Qué cable debe cortar: amarillo, rojo, azul o verde??","¡¡¡Bomba detectada!!!","Ingrese el color del cable aquí...") If Dict.Exists (AboutBomb) luego MsgBox Dict.Item(AboutBomb) else MsgBox "¡Tu vista es mala! ¡No existe tal cable! ¡¡¡La bomba explotó!!!" fin si "********************************************************
El lenguaje VBScript utiliza un único tipo de datos: Variante, que le permite almacenar un número, cadena, fecha, valor booleano, referencia de objeto y otra información en una variable. Puede determinar el tipo de contenido de una variable utilizando un conjunto de funciones: Tipo de Var, TypeName, IsArray, IsDate, IsEmpty, IsNull, IsNumeric, IsObject, que se analizarán a continuación. El tipo de información contenida también se denomina subtipo variante. En la siguiente tabla se proporciona una lista completa de subtipos: de -3.402823E38 a -1.401298E-45. Para los positivos, de 1.401298E-45 a 3.402823E38. 79769313486232E308 a -4.94065645841247E-324. Para los positivos: de 4.94065645841247E-324 a 1.79769313486232E308. Dependiendo de la expresión en la que esté involucrada la variable, su contenido se convertirá automáticamente al tipo deseado. Considere este ejemplo: Opción Subtest explícitoVBScript Dim A, B A = 5 B = "12" Application.MessageBox A + B, "", vbOkOnly End Sub Dado que la expresión involucra una variable numérica A, el intérprete convierte el valor de la variable B de cuerda "12"
en un número y los resume: Cambiemos la macro para que la variable A también contenía la línea: Opción Subtest explícitoVBScript Dim A, B A = "5" B = "12" Application.MessageBox A + B, "", vbOkOnly End Sub Ejecutémoslo. Ahora aparecerá en pantalla el resultado de la fusión (concatenación) de dos cadenas, y no la suma de sus representaciones numéricas: Para evitar confusiones con la conversión automática de tipos, se recomienda utilizar las funciones de conversión: CBool, CByte, CCur, CDate, CDbl, CInt, CLng, CSng, CStr. Si el resultado de la expresión debe ser una concatenación de cadenas, y no la suma de sus representaciones numéricas, entonces se debe utilizar el operador & en lugar de +. Una variable es una representación simbólica conveniente de un área de memoria donde una aplicación almacena algunos datos. Durante la ejecución de la aplicación, el valor de una variable puede cambiar. Antes de su uso, se debe declarar una variable mediante la declaración Dim. Usando un operador, puede declarar varias variables a la vez, si enumera sus nombres separados por comas: Atenuar izquierda, derecha, arriba, abajo Al declarar, no es necesario especificar el tipo de datos, ya que todas las variables son de tipo Variante. Si la opción explícita no se especifica en la primera línea del texto del script, entonces las variables se pueden usar sin declaración. Pero este camino puede conducir a errores difíciles de detectar. Basta con escribir mal el nombre de una variable en el texto del programa una vez para obtener un resultado impredecible. Le recomendamos que siempre especifique la opción explícita y declare las variables. El nombre de la variable debe cumplir los siguientes requisitos: El alcance de una variable está determinado por el lugar donde fue declarada. Si está dentro del cuerpo de un procedimiento, dicha variable se denomina local y está disponible sólo dentro de este procedimiento. Si una variable se declara en el texto de un script, será visible para todos los procedimientos o funciones definidas en este script. Las variables locales pueden tener el mismo nombre si se declaran en procedimientos diferentes. En el árbol del Explorador de la ventana del Editor de objetos de script hay una sección especial, Constantes y variables, para declarar variables globales visibles para todas las funciones de script del proyecto. El intérprete asigna memoria para las variables locales en el momento en que se declaran y las libera al salir del procedimiento. Las variables globales existen desde el momento en que se declaran hasta que el script termina de ejecutarse. En relación con Gedymin, esto significa que existen variables globales durante toda la ejecución del programa. El valor de una variable declarada se asigna mediante el operador =. El nombre de la variable se indica a la izquierda del operador, el nuevo valor se indica a la derecha. Por ejemplo: A = 200 B = "Nombre" Una variable que contiene un solo valor se llama escalar. A veces, es necesario almacenar varios valores en una variable. En este caso, debes declarar una matriz. La sintaxis de la declaración es idéntica a la declaración de una variable escalar, con la excepción de que después del nombre entre paréntesis especificamos el tamaño de la matriz. La siguiente declaración creará una matriz de 12 elementos: Meses oscuros(11) En VBScript, el límite izquierdo del índice de una matriz es siempre 0. Por lo tanto, el tamaño de la matriz se calcula como el número entre paréntesis más uno. Al asignar un valor a un elemento de la matriz, especifique su índice entre paréntesis: Meses(0) = "Enero" Meses(1) = "Febrero" Meses(2) = "Marzo" ... Meses(10) = "Noviembre" Meses(11) = "Diciembre" De manera similar, al acceder al valor de un elemento, utilizamos su índice: NombreMes = Meses(5) La matriz no tiene por qué ser unidimensional. VBScript nos permite especificar hasta 60 dimensiones al declarar una matriz. Por ejemplo, la siguiente declaración creará una matriz bidimensional de 12 filas y dos columnas: Días de mes oscuros (11, 1) Al acceder a elementos de una matriz multidimensional, se deben especificar todos los índices: DíasMes(0, 0) = "Enero" DíasMes(0, 1) = 31 DíasMes(1, 0) = "Febrero" DíasMes(1, 1) = 28 ... Arriba declaramos matrices cuyo tamaño no cambia durante la operación del programa. Si no sabes de antemano cuántos elementos necesitarás, puedes declarar una matriz dinámica: Antes de usarlo, debe configurar el tamaño de la matriz dinámica usando el operador ReDim: Redim A(25) Durante la ejecución, puede llamar al operador ReDim varias veces y cambiar el tamaño de la matriz cada vez. La opción Conservar conserva los valores de los elementos de la matriz al cambiar el tamaño. Por ejemplo, el siguiente código aumentará la matriz declarada anteriormente en cinco elementos, dejando los existentes intactos: Reserva ReDim A(30) Recuerda que al reducir el tamaño del array, los valores de los elementos eliminados se perderán irremediablemente. Usando el operador Borrar, puede borrar los elementos de una matriz fija o liberar la memoria ocupada por una matriz dinámica. Atenuar A Redim A(25) ... Borrar A Es una buena regla general declarar constantes para valores que se utilizan repetidamente en el texto del programa. Un nombre constante asignado correctamente mejora la legibilidad y su uso simplifica el proceso de realizar cambios en el código. A diferencia de las variables, el valor de una constante no se puede cambiar durante la ejecución del programa. Se crea una constante usando el operador Const: Const CountryName = "Bielorrusia" Const CountryCode = 375 Se pueden declarar varias constantes dentro de una declaración, separadas por comas. Al igual que una variable, una constante tiene su propio alcance dependiendo de dónde (en un procedimiento o fuera de él) y cómo (Pública o Privada) fue declarada. Las constantes creadas por el operador Const sin especificar Public o Private son públicas de forma predeterminada. En el árbol del Explorador de la ventana del Editor de objetos de script hay una sección especial, Constantes y variables, para declarar constantes globales visibles para todas las funciones de script del proyecto. Los valores de las constantes de cadena están entre comillas dobles. Los valores del tipo Fecha deben estar rodeados por símbolos de almohadilla (#) y utilizar el formato americano: mes/día/año. Por ejemplo: Const Día de la Independencia Pública = #25/03/1918# Para evitar confusión entre constantes y variables, se recomienda utilizar un prefijo único para todas las constantes, como "con", o escribir el nombre de la constante en mayúsculas. Para facilitar el trabajo del programador, VBScript contiene un conjunto constantes predefinidas. Los operadores de VBScript se dividen en cinco categorías: aritmética, comparación, fusión, lógica y asignación. Formato para usar operadores de comparación: Resultado = expresión1 operador de comparación expresión2 donde se utilizan los siguientes operadores de comparación:< (меньше), <= (меньше или равно), >(mayor que), >= (mayor o igual que), = (igual a),<>(no iguales). Dependiendo de los tipos y valores de los operandos, la comparación se realiza de la siguiente manera: El operador Is especial se utiliza para comparar dos variables de objeto y devuelve Verdadero si ambas variables hacen referencia a la misma instancia de objeto. Resultado = expresión1 y expresión2 Si el operando no es una cadena, se convierte al tipo de cadena. Si ambos operandos son nulos, entonces el resultado también toma el valor Nulo; sin embargo, a diferencia de los otros operadores, si solo un operando es nulo, entonces se toma igual a la cadena vacía. Un operando establecido en Vacío también se trata como una cadena vacía "". VBScript nos proporciona los siguientes operadores lógicos: Los operandos de los operadores lógicos pueden ser expresiones booleanas o valores numéricos. En el primer caso, el resultado será una constante booleana, en el segundo, un número. Dependiendo del operador, proporcionar uno o dos valores nulos como entrada puede generar un resultado nulo. El operador Not es unario y devuelve la negación lógica de una expresión. El operador Not realiza una inversión bit a bit en un operando numérico. Los operadores lógicos restantes son binarios. La siguiente tabla muestra los resultados de ejecutar cada uno de los operadores dependiendo del valor de los operandos Exp1 y Exp2: En la vida, los operadores And y Or se utilizan con mayor frecuencia, y mucho menos Xor. En la práctica no hemos encontrado el uso de los operadores Eqv e Imp. Si le resulta difícil entender la tabla anterior, resumamos la acción de estos operadores: Cuando se ejecuta bit a bit en operandos numéricos, el resultado de un operador lógico está determinado por la siguiente tabla: El operador de asignación (=) se describe en detalle en la sección Variables. Si una expresión contiene varios operadores, se aplican según el orden establecido, lo que se denomina precedencia de operadores. Puede cambiar el orden predeterminado usando paréntesis. La expresión dentro del paréntesis siempre se evalúa primero. En una expresión que contiene operadores de diferentes categorías, primero se realizan operaciones aritméticas, luego se realizan operadores de comparación y, por último, se realizan operadores lógicos. Todos los operadores de comparación tienen la misma prioridad y se evalúan de izquierda a derecha. Los operadores aritméticos y lógicos se evalúan en el siguiente orden: Si la multiplicación y la división ocurren en la misma expresión, entonces las operaciones se realizan en orden de izquierda a derecha. Se aplica una regla similar en el caso de la presencia simultánea de operadores de suma y resta. El operador de concatenación de cadenas (&) no es aritmético y tiene prioridad entre los operadores aritméticos y de comparación. El orden de prioridad de los operadores lógicos es el siguiente: Las expresiones condicionales se utilizan para controlar el orden de ejecución de los comandos del programa y le permiten organizar transiciones (ramificaciones) y repetición de comandos. Normalmente, los operadores de comparación se utilizan junto con expresiones condicionales. La expresión de salto condicional If le permite ejecutar un grupo particular de comandos dependiendo del resultado de una expresión lógica o del valor de una variable booleana. Para ejecutar un solo comando cuando se cumple una condición determinada, utilice la sintaxis de expresión de una línea: Dim S If DatePart("w", Now) = vbMonday Then S = "Monday" Application.MessageBox S, "", vbOkOnly Tenga en cuenta que la sección Else se omite en este caso. Para ejecutar un grupo de declaraciones, debe incluirlas entre las palabras clave Then y End If. Dim S If DatePart("w", Now) = vbMonday Then S = "Hoy es lunes" Application.MessageBox S, "", vbOkOnly End If Si, cuando se cumple una condición, es necesario ejecutar un código, y cuando no se cumple una condición, se requiere otro código, entonces se utiliza la sintaxis de expresión con una sección Else: Dim S If DatePart("w", Now) = vbMonday Then S = "Hoy es lunes" Else S = "Hoy no es lunes" End If Application.MessageBox S, "", vbOkOnly Si necesita elegir entre varias alternativas, la sintaxis con la construcción ElseIf es adecuada: Dim S, D D = DatePart("w", Now) If D = vbMonday Then S = "Monday" ElseIf D = vbTuesday Then S = "Tuesday" ElseIf D = vbWednesday Then S = "Wednesday" ... Finalizar si la aplicación. Cuadro de mensaje S, "", vbOkOnly Si las declaraciones se pueden anidar: Dim S, D D = DatePart("w", Now) Si D = vbMonday Entonces S = "Lunes" De lo contrario Si D = vbTuesday Entonces S = "Martes" De lo contrario Si D = vbWednesday Entonces S = "Miércoles" De lo contrario... Fin Si finaliza si finaliza si Aunque no hay límite para el número de cláusulas ElseIf en una expresión condicional, su uso extensivo puede generar código confuso e ilegible. En caso de seleccionar una alternativa entre muchas posibles dependiendo del valor de un selector, se recomienda utilizar la expresión Select Case. Reescribamos el ejemplo de los días de la semana usando una expresión de selección: Dim S Seleccione Case DatePart("w", Now) Case vbMonday S = "Monday" Case vbTuesday S = "Tuesday" Case vbWednesday S = "Wednesday" ... Case Else Err.Raise 32000, "", "Día desconocido de semana " Fin Seleccionar Dado que la expresión del selector se evalúa solo una vez, el uso de Select..Case da como resultado un código más eficiente. Se recomienda utilizar siempre la sección Caso más para detectar valores de selector sin formato o no válidos. Muy a menudo surge una situación en la que es necesario volver a ejecutar el código. Para hacer esto, escriba una declaración de bucle que repita ciertos comandos una y otra vez. Las declaraciones de bucle se utilizan en muchas situaciones: al calcular un total sobre una lista de números, al moverse por los registros de un conjunto de datos o al ejecutar un bloque de código en varios objetos. Hay varios ciclos, que se describen en las siguientes secciones. Algunos de ellos se ejecutan mientras la condición es Verdadera, otros se ejecutan mientras la condición es Falsa. Y por último, están aquellos que se ejecutan un número determinado de veces. Este operador está diseñado para ejecutar un grupo de comandos hasta que una condición determinada sea Verdadera o hasta que se convierta en Verdadera. La condición se puede verificar como al comienzo del ciclo: Hacer [(Mientras | Hasta) condición] Bucle y así al final: Hacer bucle [(Mientras | Hasta) condición] El comando Exit Do puede aparecer un número ilimitado de veces en el cuerpo de un bucle. Normalmente se utiliza junto con una declaración condicional If...Then y permite transferir el control a la declaración inmediatamente después del ciclo. Cuando se utiliza Exit Do dentro de un bucle anidado, el control pasará al bucle exterior. El siguiente código te permite reemplazar los dados: Dim Resp, Num Do Num = Int(6 * Rnd + 1) Resp = Application.MessageBox(Num & "¿Otro número?", "",_ vbYesNo o vbQuestion) Bucle hasta Resp = vbNo Es una versión truncada del operador Do..Loop y le permite ejecutar un grupo de comandos siempre que la condición sea Verdadera. Sintaxis del operador: Mientras condición Wend Tenga en cuenta que Exit Do no tiene ningún efecto dentro de este bucle. Los bucles While...Wend se pueden anidar. Este bucle repite un conjunto determinado de comandos un número específico de veces. La sintaxis del operador es: Para contador = inicio Para finalizar Siguiente Antes de que comience el ciclo, a la variable del contador se le asigna el valor de inicio. A continuación, se comprueba la condición del contador.<= end, при step >= 0, o contador >= final, con un paso negativo. Después de ejecutar un bloque de comandos, la variable contador aumenta en el valor de paso y todo se repite desde el principio. No está prohibido cambiar el contador en el cuerpo de un bucle, pero se desaconseja encarecidamente, ya que dificulta la comprensión de la lógica del programa y su depuración. Salir para puede aparecer en el cuerpo de un bucle cualquier número de veces. Los bucles se pueden anidar. Por ejemplo, este bucle inicializa una matriz tridimensional: Dim A(9, 9, 9) Dim I, J, K Para I = 0 a 9 Para J = 0 a 9 Para K = 0 a 9 A(I, J, K) = 1 Siguiente Siguiente Siguiente La instrucción de bucle For Each...Next repite un conjunto específico de comandos para cada elemento de una matriz o colección y tiene la siguiente sintaxis: Para cada elemento del grupo Siguiente El bucle se ejecuta si hay al menos un elemento en la matriz o colección. Salir para puede aparecer en el cuerpo del bucle un número arbitrario de veces. Ilustremos el uso de For Each... A continuación, con el siguiente código, que muestra una lista de archivos del directorio raíz de la unidad c:\ Dim fso, f, f1, fc, s Establecer fso = CreateObject("Scripting.FileSystemObject") Establecer f = fso.GetFolder("c:\") Establecer fc = f.Files para cada f1 en fc s = s & f1 .name y vbNewLine Siguiente aplicación.MessageBox s, "Archivos en c:\", vbOkOnly Para ahorrar memoria y estructurar el programa, se puede formatear como procedimiento un fragmento de código que se llama repetidamente en diferentes lugares. Hay dos tipos de procedimientos en VBScript: subrutinas (Sub) y funciones (Function). Una subrutina es una secuencia de declaraciones rodeadas por las palabras clave Sub y End Sub. La subrutina puede aceptar parámetros como entrada, pero no devuelve valores. Una función, una secuencia de declaraciones entre una función y una función final, devuelve un resultado y, por lo tanto, puede usarse en una expresión. Cada procedimiento debe tener un nombre que sea único dentro del módulo. Los nombres de los procedimientos declarados en un módulo global deben ser únicos dentro de todo el proyecto. La definición de subrutina y función tiene la siguiente sintaxis: | Privado] Subnombre [(arglist)] Fin Sub | Privado] Nombre de la función [(arglist)] Función final Los procedimientos públicos son globales y están disponibles en todos los guiones del programa. Los trámites privados sólo están disponibles en el script donde fueron declarados. Salvo que se especifique lo contrario, el procedimiento declarado es público. La palabra clave Default sólo se puede utilizar en el cuerpo de una clase y sirve para especificar el método predeterminado de esta clase. La lista de parámetros tiene la siguiente sintaxis: Nombre de usuario [, ...] Los parámetros se pueden pasar por valor (ByVal) o por referencia (ByRef). De forma predeterminada, todos los parámetros se pasan por valor. Las constantes, los resultados de la evaluación de expresiones, sólo se pueden pasar por valor. Cambiar el parámetro pasado por referencia cambiará el valor de la variable externa. Expliquemos el paso de parámetros dentro de un procedimiento usando el siguiente ejemplo: Sub DoCalculation(ByRef A, ByVal B, ByVal C) A = C * 2 B = C / 2 End Sub Sub TestVar Dim V1, V2 V1 = 1 V2 = 2 DoCalculation V1, V2, 10 " Después de realizar el procedimiento DoCalculation " V1 = 20" V2 = 2 sub finales Las variables declaradas dentro del cuerpo de un procedimiento son locales y se destruyen al finalizar su ejecución. Los valores de las variables locales no se guardan. La lista de parámetros se especifica entre paréntesis cuando se llama a una función o cuando se llama a una subrutina mediante la instrucción Call. Entonces, podríamos escribir la llamada al procedimiento DoCalculation en el ejemplo anterior de la siguiente manera: Llamar a DoCalculation(V1, V2, 10) VBScript le permite crear nuevas clases, que en adelante llamaremos clases VB. En general, no son clases completas en el sentido de la programación orientada a objetos, ya que no admiten herencia y, en consecuencia, polimorfismo. Entonces, de los tres pilares en los que se basa el paradigma orientado a objetos, solo queda la encapsulación: la capacidad de combinar datos y métodos dentro de una entidad. Una clase se define utilizando la siguiente construcción: Declaraciones de nombre de clase Fin de clase donde nombre es el nombre de la clase y las declaraciones son una o más definiciones de variables, propiedades, procedimientos o funciones, también llamadas miembros de la clase. Tenga en cuenta que, a diferencia de Delphi, donde el código de definición de clase contiene solo declaraciones de procedimientos y funciones, en una clase VB el código miembro se escribe directamente en el texto de la clase. Los miembros de una clase pueden ser declarados Privados o Públicos. Los primeros son visibles sólo dentro del código de una clase determinada, mientras que los segundos están disponibles tanto para el código interno como externo. Si una variable o función (procedimiento) no contiene una definición explícita de Público o Privado, entonces se considera pública. Los procedimientos o funciones declarados como Públicos dentro de un bloque de clase se convierten en métodos de esa clase. Las variables declaradas como públicas se convierten en propiedades de clase junto con las propiedades declaradas directamente mediante las construcciones Property Get, Property Let y Property Set. Ya dijimos anteriormente que los campos de una clase, declarados explícita o implícitamente como Públicos, pasan a ser sus propiedades. Además, puede crear una propiedad de clase definiendo funciones especiales para leer el valor de la propiedad (Property Get), así como para asignarlo (Property Let o Property Set). La sintaxis para definir dichas funciones es la siguiente: | Privado] Propiedad Obtener nombre [(arglist)] [nombre = expresión] [nombre = expresión] Fin de propiedad Propiedad Let nombre (valor) Fin de propiedad Propiedad Establecer nombre (referencia) Fin de propiedad Al definir solo una función, leer o asignar, puede crear una propiedad que sea de solo lectura o de solo escritura, respectivamente. El procedimiento Property Let se utiliza para asignar tipos de datos simples y el procedimiento Property Set se utiliza para pasar una referencia a un objeto. Tenga en cuenta que las tres funciones pueden tomar una lista arbitraria de parámetros como entrada. De esta manera, puede organizar, por ejemplo, las propiedades de una matriz pasando el índice del elemento como argumento. La creación de una instancia de una clase VB se realiza mediante el operador Nuevo. Dim X Set X = Nuevo nombre de clase La destrucción de una instancia creada previamente se produce automáticamente al completarse el bloque de código donde se declaró la variable correspondiente y siempre que no existan referencias externas a la misma. Si necesita destruir la instancia manualmente, debe asignar el valor Nothing a la variable. ‘declarando una variable y creando una instancia de la clase Dim X Set X = Nuevo nombre de clase...’ usando la instancia de clase... ‘destruyendo la instancia de clase Set X = Notning... El evento Inicializar ocurre cuando se crea una instancia de una clase y el evento Terminar ocurre cuando se destruye. El desarrollador puede definir sus propios controladores de datos de eventos. A continuación se muestra un ejemplo del uso de eventos de creación y eliminación de objetos: Class TestClass " Definición del controlador de eventos Inicializar. Private Sub Class_Initialize MsgBox("TestClass comenzó") End Sub " Definición del controlador de eventos Terminar.Métodos y propiedades de la clase raíz de WScript
Métodos y propiedades de la clase Shell.
Métodos y propiedades de la clase Network.
Métodos y propiedades de la clase FileSystemObject.
Escenario "Eliminar archivos antiguos"
Enlaces externos
Función cuadro de mensajes
Sintaxis: MsgBox (Mensaje[, Botones][, Título][, Archivo de ayuda, Contexto])Constantes para cuadros de diálogo (botones de visualización):
Constantes para cuadros de diálogo (iconos mostrados):
Constantes para cuadros de diálogo (botones predeterminados):
Constantes para cuadros de diálogo (modo ventana):
Otro:
Devuelve el resultado de los botones presionados (constantes):
Tipos de datos
Subtipo
Descripción
Vacío
A la variable no se le ha asignado un valor. Cuando se utiliza una variable no inicializada en expresiones numéricas, se sustituirá 0 y, en expresiones de cadena, se sustituirá una cadena vacía.
Nulo
La variable no contiene datos.
Booleano
Una variable booleana puede tomar los valores Verdadero o Falso.
Byte
Un número entero que va de 0 a 255.
Entero
Un número entero en el rango -32.768 a 32.767.
Divisa
Un número de punto fijo en el rango -922.337.203.685.477,5808 a 922.337.203.685.477,5807.
Largo
Un número entero en el rango -2.147.483.648 a 2.147.483.647.
Soltero
Número de coma flotante de precisión simple. Para valores negativos el rango aceptable es
Doble
Número de coma flotante de doble precisión. Para valores negativos, el rango aceptable es de
Fecha (hora)
Contiene un número que representa una fecha en el rango del 1 de enero de 100 al 31 de diciembre de 9999.
Cadena
Secuencia de personajes. La longitud máxima es de unos 2 mil millones de caracteres.
Objeto
Objeto.
Error
Número de error.
variables
Alcance y vida útil
Asignar un valor a una variable
Variables escalares y matrices
Constantes
Operadores
Operadores aritméticos
Operador
Ejemplo de uso
Descripción
^
numero^exponente
Eleva el número al exponente. El número sólo puede ser menor que cero si es una potencia entera. Si uno de los operandos es nulo, toda la expresión es nula. Si se realizan varias exponenciaciones seguidas, el resultado se calcula de izquierda a derecha.
*
número1 * número2
Producto de dos números. Si el operando tiene el valor Vacío, se supone que es cero. Si al menos uno de los operandos es nulo, toda la expresión se evalúa como nula.
/
número1 / número2
División real de dos números. Las reglas para los operandos son similares a las del operador de multiplicación.
\
número1\número2
División entera. Antes de la evaluación, ambos operandos se convierten en Byte, Integer o Long. De lo contrario, se aplican las mismas reglas que para el operador de división.
Modificación
número1 Mod número2
Resto de la división de números enteros. Conversión de operandos a un número entero, así como reglas para manejar vacíos y nulos, como la división de enteros.
+
expresión1 + expresión2
Si ambos operandos son números, el resultado es su suma aritmética. Si ambos operandos son cadenas, se trata de una fusión (concatenación) de dos cadenas. Si un operando es un número y el otro es una cadena, entonces el operando de cadena se convertirá en un número y se sumará al numérico. Si al menos uno de los operandos es nulo, toda la expresión se evalúa como nula. Si ambos operandos están vacíos, el resultado tiene el valor entero 0. Si solo un operador está vacío, el valor del segundo operando se devuelve como resultado.
-
número1 – número2 o - número
En el primer caso, devuelve la diferencia de dos números. En el segundo, invierte el signo del número. Reglas para operandos con valores Nulos y Vacío, como para el operador de multiplicación.
Operadores de comparación
Si
Eso
Ambos operandos son números.
Se hace una comparación entre dos números.
Ambos operandos son cadenas.
Se realiza una comparación de dos cadenas.
Uno de los operandos es un número y el segundo es una cadena.
El operando de cadena se convierte en un número y se realiza una comparación entre los dos números.
Uno de los operandos está vacío y el segundo es un número.
Se supone que el operando con el valor Vacío es 0.
Uno de los operandos está vacío y el segundo es una cadena.
El operando con el valor Vacío se considera la cadena vacía "". Se hace una comparación entre dos cadenas.
Ambos operandos están vacíos.
Los operandos se consideran iguales.
Al menos uno de los operandos es nulo.
El resultado es nulo.
Operadores de concatenación
Operadores lógicos
Exp1
Exp2
Y
O
xor
Eqv
Diablillo
Verdadero
Verdadero
Verdadero
Verdadero
FALSO
Verdadero
Verdadero
Verdadero
FALSO
FALSO
Verdadero
Verdadero
FALSO
FALSO
FALSO
Verdadero
FALSO
Verdadero
Verdadero
FALSO
Verdadero
FALSO
FALSO
FALSO
FALSO
FALSO
Verdadero
Verdadero
Verdadero
Nulo
Nulo
Verdadero
Nulo
Nulo
Nulo
FALSO
Nulo
FALSO
Nulo
Nulo
Nulo
Verdadero
Nulo
Verdadero
Nulo
Verdadero
Nulo
Nulo
Verdadero
Nulo
FALSO
FALSO
Nulo
Nulo
Nulo
Nulo
Nulo
Nulo
Nulo
Nulo
Nulo
Nulo
Nulo
Exp1
Exp2
Y
O
xor
Eqv
Diablillo
0
0
0
0
0
1
1
0
1
0
1
1
0
1
1
0
0
1
1
0
0
1
1
1
1
0
1
1
Operador de asignación
El orden de aplicación de los operadores.
Expresiones condicionales
Si... Entonces... Si no expresión
Seleccione...Expresión de caso
Declaraciones de bucle
Operador Do..Loop
Mientras..Wend
Para...Siguiente
Para cada uno...Siguiente
Trámites
Ejecutar expresión
Clases de VBScript
Definición de propiedades de clase
Crear y destruir una instancia de una clase VB
Inicializar y finalizar eventos