Tema 1.2 - Fundamentos

Tipos de datos y variables

Tipos de datos

En AutoIt sólo hay un tipo de dato llamado Variant. Un variant puede contener datos numéricos, cadenas de caracteres, entre otros que pueden ser usados dependiendo de la situación en la que usted se encuentre. A continuación, se muestra una tabla con los subtipos de datos de variant y sus respectivos rangos.

Números enteros (Int32 e Int64):

• Los enteros pueden ser: 1, 10, 4596, -7, entre otros.
• Estos números también pueden ser escritos en notación científica, como, por ejemplo: 1.5e3 daría como resultado el número 1500 o -2.7e4 tendría como resultado el valor de -270000.

Números flotantes o decimales (Double):

• Estos números pueden ser: 1.7, 123.1456, -0.125, etc.

Cadena de caracteres (String):

• Las cadenas se identifican porque están encerradas con comillas dobles (“”) o comillas simples (‘’). Por ejemplo: “hola mundo”, ‘hola mundo’, “q-vision”, ‘Quality Vision Technologies’, “123”, ‘0.2654’, etc.
• También se pueden mezclar los dos tipos de comillas. Por ejemplo: Si queremos usar muchas comillas dobles en nuestra cadena, debemos declararlas en comillas simples de la siguiente manera: ‘Esta oración “contiene” muchas “comillas dobles”, cierto?’.

Boolean

• Pueden ser usados en la asignación de variables, junto a los operadores booleanos Not, And y Or.

Ejemplo: Para realizar este ejemplo, primero vamos a crear nuestro script de AutoIt y para ello existen dos maneras:

1. Primera forma: Nos dirigimos a cualquier carpeta en donde desee crear el script, luego de situarse en dicho lugar, presiona clic derecho -> Nuevo -> AutoIt v3 Script, se crea el archivo con extensión .au3 y le ponemos como nombre boolean_ejemplo1.





2. Segunda forma: En el buscador de Windows escribimos SciTE Script Editor y le damos clic a la aplicación.



Luego se abrirá el editor, cuando esto suceda procedemos a guardar el archivo escogiendo la ubicación que queramos y le damos como nombre boolean_ejemplo1.

Ahora que hemos creado nuestro script, nos posicionamos en él y escribimos las siguientes líneas de código.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

#include <MsgBoxConstants.au3>

$bBoolean = True	; $bBoolean es una variable

MsgBox($MB_OK,"Prueba 1", $bBoolean)	; El resultado es True
MsgBox($MB_OK,"Prueba 2", True And False)	; El resultado es False
MsgBox($MB_OK,"Prueba 3", True Or False)	; El resultado es True
MsgBox($MB_OK,"Prueba 4", False And False)	; El resultado es False
MsgBox($MB_OK,"Prueba 5", False Or False)	; El resultado es False
MsgBox($MB_OK,"Prueba 6", True And (Not False))	; El resultado es True

Luego ejecutamos el script y para esto hay varias formas, una de ellas es ir al archivo boolean_ejemplo1 y dar clic derecho -> Run Script o también podemos estar en la ventana de nuestro script e ir a Tools -> Go.

Cuando lo ejecutemos veremos varias cajas de mensajes con los resultados de las distintas operaciones que podemos hacer con los operadores booleanos.

Notas:

1. El #include que aparece en la línea 1 de nuestro script es una directiva que permite incluir archivos adicionales, en este caso agregamos el archivo MsgBoxConstants.au3 que se encuentra la carpeta AutoIt3 -> Include para poder utilizar la constante global $MB_OK. En caso de no querer usar esta constante, puede reemplazarla por 0 y quitar el include.
2. Para saber más sobre la directiva #include ingrese a este enlace Directiva Include. Si lo desea también puede ingresar a este enlace Función MsgBox para conocer qué parámetros puede llevar la función MsgBox().
3. $bBoolean es una variable, este tema se abordará más adelante.
4. El signo punto y coma (;) representa comentarios.

• Si los valores booleanos (True y False) se implementan junto a números en operaciones And, Or y Not, entonces se seguirán las siguientes reglas:

1. El valor 0 será tomado como False.
2. Los otros valores numéricos serán tomados como True.

Ejemplo: Creamos un script llamado boolean_ejemplo2 y en él escribimos el siguiente código.

1
2
3

MsgBox(0, "Prueba 1", True And (Not 0)) ; El resultado es True
MsgBox(0, "Pureba 2", False Or 12) ; El resultado es True
MsgBox(0, "Prueba 3", False And -2.5) ; El resultado es False

Si corremos el script, nos dará como resultado.

• Si se usan operaciones aritméticas junto a los valores booleanos (lo cual no es recomendable), se seguirán las siguientes reglas:
1. El booleano True se convertirá en el valor numérico 1.
2. El booleano False se convertirá en el valor numérico 0.

Ejemplo: Creemos un script llamado boolean_ejemplo3 y en él escribamos el siguiente código.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

$suma = True + 2 ; 1 + 2 = 3
$resta = 40 - False ; 40 - 0 = 40
$mult = False * 20 ; 0 * 20 = 0
$div = 100 / True ; 100 / 1 = 100
MsgBox(0, "Suma", "La suma es igual a: "&$suma) ; La suma es igual a 3
MsgBox(0, "Resta", "La resta es igual a: "&$resta) ; La resta es igual a 40
MsgBox(0, "Multiplicación", "La multiplicación es igual a: "&$mult) ; La multiplicación
                                                                 ;es igual a 0
MsgBox(0, "División", "La división es igual a: "&$div) ; La división es igual a 100

Luego ejecutamos el script y tendremos lo siguiente.

Notas:

1. $suma, $resta, $mult y $div son variables. El tema de variables se verá más adelante.
2. El signo ampersand (&) es el operador de concatenación.

• Si se usan los valores booleanos junto a cadenas de caracteres (strings), los booleanos se convertirán de la siguiente manera:
1. El booleano True se convertirá en la cadena “True”.
2. El booleano False se convertirá en la cadena “False”:

Ejemplo: Abrimos un script, lo nombramos boolean_ejemplo4 y escribimos el siguiente código.

1

MsgBox(0, "Booleano + String", "La prueba es: "&True)

Cuando ejecutamos el script, el booleano de valor True al estar concatenado con una cadena, éste se convierte en la cadena “True”. A continuación, se muestre el resultado.

Variables

Una variable es un espacio de memoria para almacenar datos para que se puedan acceder a ellos rápidamente. Cada variable tiene un nombre y empiezan con el carácter signo de pesos ($) y solo deben contener letras, números y el carácter guion bajo (_). A continuación, se muestra algunos ejemplos de nombres de variables.

1. $var1
2. $mi_Variable
3. $vVariable

Las variables no distinguen entre minúsculas y mayúsculas, es decir, la variable $miVariable es lo mismo que $MiVariaBle.

Para facilitar el mantenimiento de los scripts y tener una idea de qué tipo de variable se está declarando, se recomienda utilizar la nomenclatura estándar al momento de declarar nuestras variables. Ejemplifiquemos esto mediante la siguiente tabla.

Al momento de declarar las variables usando la nomenclatura estándar tenga en cuenta lo siguiente:

1. El prefijo siempre debe ser en minúscula.
2. El nombre de la variable debe empezar en mayúscula.

Si desea observar la lista completa de nomenclaturas que se propone, puede ingresar al enlace convención de nomenclatura variable estándar.

Declaración de variables: Las variables se declaran y se crean usando las palabras claves Local, Global y Dim, aunque esta última no es tan recomendable. Las variables pueden ser declaradas sin la necesidad de utilizar Local, Global o Dim, pero es preferible declararlas de manera explícita.

También se pueden declarar y crear constantes utilizando la palabra clave Const. Las constantes y variables se diferencian debido que las constantes deben obligatoriamente ser inicializadas, mientras que en las variables no es necesario hacer esto.

Ahora se muestra la sintaxis para declarar una variable y una constante.

1

Global | Local [Const] $variable [ = inicializador ]

Donde:

1. La palabra reservada Const es opcional. Si está presente significa que se crea una constante y no una variable.
2. $variable es el nombre de la variable o constante que vayamos a declarar.
3. El inicializador es el valor que se asignará inicialmente a la variable. Una constante debe incluir el inicializador. El inicializador puede ser una llamada a una función.

Ejemplo: Creamos un script con nombre prueba_constante y en él ponemos el siguiente código.

1
2
3
4

Global Const $fPi

$fPi = 3.14159
MsgBox(0, "PI", "El valor de PI es: "&$fPi)

Si corremos este script, veremos que nos saldrá un error de sintaxis y se debe a que lo que se declaró fue una constante, por ende, se debe inicializar con un valor desde el principio. Para corregir este error, debemos inicializarlo desde el inicio y borrar la línea 3 del código anterior.

1
2
3

Global Const $fPi = 3.14159

MsgBox(0, "PI", "El valor de PI es: "&$fPi)

Ahora si volvemos a ejecutar el script, nos debería funcionar correctamente.

Operadores

AutoIt tiene los siguientes operadores de asignación, concatenación, matemático y lógicos.

Estructuras de Control

Declaraciones condicionales

Se utilizan cuando se quiera cambiar el flujo de un script en función de una o más condiciones. Las condiciones se evalúan como True o False. Estas condiciones por lo general usan los operadores de comparación.

A continuación, se presentan los condicionales que se encuentran en AutoIt.

• Estructura If: La sintaxis es la siguiente.

1 2 3 4 5 6 7 8 9

If <condicion> Then ;instrucciones... [ElseIf condicion-n Then ;instrcucciones elseif... ] [Else ;instrucciones else... ] EndIf

• Los corchetes representan las partes del código que son opcionales, en este caso serían el ElseIf y Else.
• El ElseIf puede aparecer varias veces.
• Si la condicion es verdadera, se ejecuta el primer bloque de instrucciones, si no, ejecuta el primer bloque ElseIf verdadero. De lo contrario, se ejecuta el bloque Else.
• La condicion puede contener operadores booleanos (lógicos) And, Or y Not, así como operadores de comparación <, <=, >, >=, =, ==, y <> agrupados con paréntesis según sea necesario.
• Las declaraciones If pueden estar anidadas.

Ejemplo: Para observar el funcionamiento de la declaración If…ElseIf...Else creamos un script que lleve como nombre If…ElseIf…Else y luego escribamos el siguiente código.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

Local $iDia = 4

If $iDia = 1 Then
	MsgBox(0,"Día de la semana", "Hoy es Lunes")
ElseIf $iDia = 2 Then
	MsgBox(0,"Día de la semana", "Hoy es Martes")
ElseIf $iDia = 3 Then
	MsgBox(0,"Día de la semana", "Hoy es Miércoles")
ElseIf $iDia = 4 Then
	MsgBox(0,"Día de la semana", "Hoy es Jueves")
ElseIf $iDia = 5 Then
	MsgBox(0,"Día de la semana", "Hoy es Viernes")
ElseIf $iDia = 6 Then
	MsgBox(0,"Día de la semana", "Hoy es Sábado")
ElseIf $iDia = 7 Then
	MsgBox(0,"Día de la semana", "Hoy es Domingo")
Else
	MsgBox(0,"Día de la semana", "El número no coincide")
EndIf

Corremos el script y tendremos este resultado.

• Estructura Select: La declaración Select es muy similar al If/ElseIf con la diferencia de que esta se usa generalmente para situaciones en la que se desea probar una gran cantidad de condiciones.

La sintaxis de Select es:

1 2 3 4 5 6 7 8 9 10 11 12 13

Select Case <condicion-1> ;instrucciones condicion-1 [Case <condicion-2> ;instrucciones condicion-2 ] [Case <condicion-n> ;instrucciones condicion-n ] [Case Else ;instrucciones else ] EndSelect

• Los corchetes representan las partes de la sintaxis que son opcionales.
• La condicion puede contener los operadores booleanos And, Or y Not, así como también de operadores de comparación <, <=, >, >=, =, == y <> agrupados con paréntesis según sea necesario.
• La declaración Case puede aparecer varias veces.
• Si la condicion es verdadera, se ejecutan las instrucciones hasta el siguiente Case o EndSelect. Si hay más de una declaración Case verdadera, solo se ejecuta la primera.

Ejemplo 1: Acá vamos a realizar el mismo ejemplo de los días de la semana hecho con If/ElseIf, pero en esta ocasión lo haremos con el bloque Select/Case. Entonces agregamos un nuevo script, lo nombramos Select (1) y por último escribimos este código.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

Local $iDia = 4

Select
	Case $iDia = 1
		MsgBox(0,"Ejemplo Select","Hoy es Lunes")
	Case $iDia = 2
		MsgBox(0,"Ejemplo Select","Hoy es Martes")
	Case $iDia = 3
		MsgBox(0,"Ejemplo Select","Hoy es Miércoles")
	Case $iDia = 4
		MsgBox(0,"Ejemplo Select","Hoy es Jueves")
	Case $iDia = 5
		MsgBox(0,"Ejemplo Select","Hoy es Viernes")
	Case $iDia = 6
		MsgBox(0,"Ejemplo Select","Hoy es Sábado")
	Case $iDia = 7
		MsgBox(0,"Ejemplo Select","Hoy es Domingo")
	Case Else
		MsgBox(0,"Ejemplo Select","El número no coincide")
EndSelect

Luego de escribir el código, ejecutamos el script.

Ejemplo 2: Creemos un script con nombre Select (2) y en ella colocamos el siguiente código.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

Local $iNumero = 15

Select
	Case $iNumero>=1 And $iNumero<=10 ; 1er Case
		MsgBox(0,"Ejemplo Select 2","$iNumero está entre 1 y 10")
	Case $iNumero>=13 And $iNumero<=17 ; 2do Case
		MsgBox(0,"Ejemplo Select 2","$iNumero está entre 13 y 17 ")
	Case $iNumero>=11 And $iNumero<=20 ; 3er Case
		MsgBox(0,"Ejemplo Select 2","$iNumero está entre 11 y 20")
	Case $iNumero>=21 And $iNumero<=30 ; 4to Case
		MsgBox(0,"Ejemplo Select 2","$iNumero está entre 21 y 30 ")
	Case Else ; 5to Case
		MsgBox(0,"Ejemplo Select 2","$iNumero no está en los rangos permitidos")
EndSelect

Ponemos a correr el script y obtendremos esta respuesta.

Observemos que en este ejemplo el 2do y 3er Case cumplen la condición debido a que $iNumero se encuentra en esos rangos, pero siempre ingresará al primer Case verdadero y ejecutará las instrucciones que hay en él, por eso que entró al 2do Case. Si no se hubiese encontrado ninguna condición verdadera, entonces entraría al Case Else y haría la instrucción que en ella se colocó.

• Estructura Switch: Esta declaración es muy similar a Select, con la diferencia de que ésta se utiliza generalmente para situaciones donde la misma expresión es probada con algunos valores posibles diferentes. La sintaxis de esta declaración condicional es la siguiente.

1 2 3 4 5 6 7 8 9 10

Switch <expresion> Case <valor> [To <valor>] [,<valor> [To <valor>]...] ;instrucciones [Case <valor> [To <valor>] [,<valor> [To <valor>]...] ;instrucciones ] [Case Else ;instrucciones ] EndSwitch

• Los corchetes representan las partes del código que son opcionales.
• La expresion es una expresión que retorna un valor. El valor de expresión se compara con los valores de cada Case hasta que se encuentre una coincidencia.
• Si colocamos valor en nuestro Case, éste se ejecutará si la expresión coincide con el valor.
• Si colocamos valor To valor en nuestro Case, éste se ejecutará si la expresión está entre los dos valores.
• Los Case pueden estar 1 o N veces en la declaración Switch.
• Si ningún caso coincide con el valor de la expresión, se ejecuta la sección Case Else, si está presente. Si el valor de la expresión no coincide con ninguno de los valores de los Case y Case Else no está definido, entonces no se ejecutará ninguna de las instrucciones de la estructura Switch.

Ejemplo 1: Hagamos el mismo ejemplo de los días de la semana utilizando la estructura Switch. Para hacer esto, creemos un nuevo script que lo llamaremos Swtich (1) y en él ponemos este código.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

Local $iDia = 4

Switch $iDia
	Case 1
		MsgBox(0,"Ejemplo Switch","Hoy es Lunes")
	Case 2
		MsgBox(0,"Ejemplo Switch","Hoy es Martes")
	Case 3
		MsgBox(0,"Ejemplo Switch","Hoy es Miércoles")
	Case 4
		MsgBox(0,"Ejemplo Switch","Hoy es Jueves")
	Case 5
		MsgBox(0,"Ejemplo Switch","Hoy es Viernes")
	Case 6
		MsgBox(0,"Ejemplo Switch","Hoy es Sábado")
	Case 7
		MsgBox(0,"Ejemplo Switch","Hoy es Domingo")
	Case Else
		MsgBox(0,"Ejemplo Switch","El número no coincide")
EndSwitch

Si ejecutamos el script nos dará el siguiente resultado.

Ejemplo 2: Ahora haremos que nuestra expresión en el Switch compare su valor con un rango de valores especificados que hay en cada Case e ingresará solo al que cumpla la condición, entonces para ver esto creamos un nuevo script y lo nombramos Switch (2).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

Local $iNumero = 22
Local $sMensaje = ""

Switch $iNumero
	Case 1 To 10
		$sMensaje = "$iNumero está entre 1 y 10"
	Case 11 To 20
		$sMensaje = "$iNumero está entre 11 y 20"
	Case 21 To 30
		$sMensaje = "$iNumero está entre 21 y 30"
	Case 31 To 40
		$sMensaje = "$iNumero está entre 31 y 40"
EndSwitch

MsgBox(0,"Ejemplo Switch 2",$sMensaje)

Ejecutamos el script y nos da este resultado.

Declaraciones de bucle

Un ciclo o bucle es una sección del script que se repite varias veces siempre y cuando una determinada condición sea falsa o verdadera. AutoIt tiene disponible las siguientes declaraciones de bucle:

• Estructura For: La sintaxis de esta estructura es la siguiente.

1 2 3

For <variable> = <inicio> To <fin> [Step <contador>] ;instrucciones Next

• Los corchetes representan las partes de la sintaxis que son opcionales.
• <variable> es la variable que va a hacer usada para el conteo.
• <inicio> es el valor numérico inicial que tendrá <variable>.
• <fin> es el valor numérico final que tendrá <variable>.
• <contador> es un valor numérico (posiblemente decimal) que aumenta el recuento en cada ciclo. Su valor por defecto es 1.
• Las declaraciones For pueden estar anidadas.
• El bucle For termina cuando el valor de la <variable> excede el valor de <fin>.
• Las dos únicas maneras para que el bucle no se ejecute son: <inicio> sea mayor que <fin> y <contador> sea mayor o igual a cero; la segunda manera es que <inicio> sea menor que <fin> y <contador> sea negativo.

Ejemplo: Lo que haremos será utilizar la estructura del bucle For para mostrar los números del 1 al 8. Crearemos un script al cual llamaremos Estructura For y en él coloquemos este código.

1
2
3
4
5
6
7

Local $iNumero
Local $iInicio = 1
Local $iFin = 8

For $iNumero = $iInicio To $iFin
	MsgBox(0,"Ejemplo For",$iNumero)
Next

Al ejecutar el script, nos saldrá varias cajas de mensaje mostrando los números del 1 al 8.

Ejemplo 2: Ahora haremos que el bucle For vaya desde 0 hasta 10, pero en saltos de a dos y para lograr esto debemos poner el contador igual a 2.

Para este ejemplo, crearemos otro script con nombre Estructura For 2 y agregamos el siguiente código.

1
2
3
4
5

Local $iNumero

For $iNumero = 0 To 8 Step 2
	MsgBox(0,"Ejemplo For 2",$iNumero)
Next

Ponemos a correr el script y obtendremos los siguientes resultados.

• Estructura While: Su sintaxis se muestra a continuación.

1 2 3

While <condicion> ;instrucciones WEnd

• Si <condicion> es verdadera, se ejecutarán todas las instrucciones que estén en el bloque While. Este continúa hasta que <condicion> sea falso.
• Las declaraciones While pueden estar anidadas.
• La <condicion> se prueba si es verdadera o falsa antes de ejecutar el bucle, por lo que las instrucciones dentro del bloque While podrán ejecutarse cero o más veces.

Ejemplo: Mostraremos los números del 1 hasta el 8 mediante el bucle While. Creamos un script con nombre Estructura While y le anexamos las siguientes líneas de código.

1
2
3
4
5
6

Local $iNumero = 1

While $iNumero <= 8
	MsgBox(0,"Ejemplo While",$iNumero)
	$iNumero += 1
WEnd

Ponemos a correr el script y obtendremos los siguientes resultados.

• Estructura Do: La sintaxis de este tipo de bucle es la siguiente.

1 2 3

Do ;instrucciones Until <expresion>

• Las instrucciones dentro del bloque Do…Until se ejecutarán hasta que <expression> sea verdadera.
• Las declaraciones Do…Until pueden estar anidadas.
• La <expression> es probada después de ejecutar el bucle, por lo que se ejecutará como mínimo una vez.

Ejemplo: Realicemos el mismo ejemplo que se hizo con la declaración While, pero esta vez usando Do. Como los demás ejemplos, creemos un nuevo script con nombre Estructura Do y en ella escribimos este código.

1
2
3
4
5
6

Local $iNumero = 1

Do
	MsgBox(0,"Ejemplo Do...Until",$iNumero)
	$iNumero = $iNumero + 1
Until $iNumero > 8

Si corremos el script, nos debe mostrar los números del 1 hasta el 8.

Funciones

Una función es un “porción” de código que se puede invocar desde cualquier parte del script para cumpla una determinada “función”. En AutoIt existen dos tipos de funciones: funciones integradas y funciones de usuario.

• Funciones integradas: Son funciones que AutoIt trae por defecto, para ver la lista completa junto a una breve descripción de ellas, puede ingresar al siguiente enlace Funciones Integradas AutoIt.
• Funciones de usuario: Las funciones definidas por el usuario se declaran de la siguiente manera.

1 2 3 4

Func nombreFuncion([Const][ByRef]$param1,...,[Const][ByRef]$paramN,$par1Opcional=valor,...) ;instrucciones [Return[valor]] EndFunc

• Los nombres de las funciones deberías empezar con una letra o guion bajo, el resto del nombre puede ser una combinación de letras, números y guiones bajos.
• Las funciones no distinguen entre mayúsculas y minúsculas, por ende, Holamundo() es lo mismo que HOlaMundo().
• Los corchetes representan las partes de la sintaxis que son opcionales.
• La palabra reservada Const es opcional e indica que el parámetro no cambiará durante la ejecución de la función. Una variable Const solo se puede pasar a una función utilizando un parámetro Const.
• Los parámetros que quiere que tenga la función usted mismo los define, puede tener variables, matrices, entre otros.
• La palabra reservada ByRef indica que el parámetro debe tratarse como una referencia al original. Por defecto, el parámetro se copia en una nueva variable, pero ByRef vincula la nueva variable al original.
• Declarar parámetros como ByRef y Const es muy útil cuando la variable global debe permanecer sin cambios ya que AutoIt devolverá un error si por alguna razón en la función se intenta cambiar el valor de esa variable.
• Los parámetros $par1Opcional son opcionales y se definen al asignarles un valor predeterminado. El valor que puede obtener estos parámetros son variables globales, marcos o simplemente valores literales.
• Los parámetros opcionales siempre deben aparecer en el último lugar en la definición de la función.
• Todos los parámetros añadidos después del primer parámetro opcional también deben ser opcionales.
• La palabra reservada Return sirve para salir de la función. A diferencia de las funciones integradas, las funciones definidas por el usuario retornan 0 a menos que se especifique otro valor de retorno.

Ejemplo: Realizaremos una función que me permita sumar dos números y me retorne el resultado a una variable que por último será mostrada en pantalla.

Entonces añadimos un nuevo script con nombre Función y escribimos el siguiente código.

1
2
3
4
5
6
7
8
9

Global $iValorSuma

$iValorSuma = Sumar(2, 6) ; invoco a la función Sumar

MsgBox(0,"Ejemplo Función","La suma es igual a: "&$iValorSuma)

Func Sumar($iNum1, $iNum2)
	Return $iNum1 + $iNum2 ; retorno la suma de los dos valores
EndFunc

Ejecutamos el script y nos mostrará el resultado de la suma que debería ser 8.

Arreglos

Un arreglo es una variable que contiene un conjunto de datos y pueden tener múltiples dimensiones. Se puede acceder a un elemento mediante un número de índice que se relaciona con la posición del elemento dentro del arreglo.

En AutoIt, el primer elemento empieza en la posición 0. Los elementos del arreglo se almacenan en un orden definido y se pueden ordenar.

A los arreglos se les debe especificar un tamaño desde el inicio ya que si no lo hace se puede ya no será un arreglo sino un Mapa (este tema no será visto en el curso).

Ejemplo 1: Lo que se mostrará a continuación, son las distintas formas de asignar valores a un arreglo.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

; 1ra forma
Local $aArray[3] = [1,2,3]

; 2da forma
Local $aArray[] = [1,2,3]

; 3ra forma
Local $aArray[3]
$aArray[0] = 1
$aArray[1] = 2
$aArray[2] = 3

; 4ta forma
Local $aArray = [1,2,3]

1. En la 2da y 4ta forma se observa que no se le definen un tamaño, pero al asignar los valores inmediatamente se crean como arreglos.
2. En la 3ra forma se muestra adicionalmente la manera como se accede a las posiciones del arreglo, ya que en esta forma accedemos a las posiciones 0, 1 y 2 que no tienen nada en ellos y se les asigna los valores 1, 2, y 3.

Ejemplo 2: Ahora es el turno de hacer una matriz. Crearemos una matriz de dimensiones 3 x 3, luego recorreremos esa matriz asignándole valores del 1 al 9 y por último mostraremos la suma de la diagonal principal.

Para lograr esto, creamos un script que tendrá como nombre Matriz y pondremos las siguientes líneas de código.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

Global $i
Global $j
Global $iContador = 0
Global $aArreglo[9] = [1,2,3,4,5,6,7,8,9]
Global $vMatriz[3][3]
Global $iDiagPrincipal = 0

; Asignamos los valores a la matriz
For $i = 0 To 2
	For $j = 0 To 2
		$vMatriz[$i][$j] = $aArreglo[$iContador]
		$iContador = $iContador + 1
	Next
Next

; Sumamos los valores de la diagonal principal
For $i = 0 To 2
	For $j = 0 To 2
		If $i = $j Then
			$iDiagPrincipal += $vMatriz[$i][$j]
		EndIf
	Next
Next

MsgBox(0,"Matriz","La suma de la diagPrincipal es: "&$iDiagPrincipal)

Al ejecutar el script y si todo está correcto, nos debería mostrar el valor 15 que es la suma de la diagonal principal (1 + 5 + 9).

Funciones String

String aparte de ser un subtipo de dato de la variable Variant posee algunas funciones que nos permiten tratar las cadenas de caracteres. A continuación, mencionaremos algunas de estas funciones.

• StringLeng: Esta función me retorna el número de caracteres (longitud) que hay dentro del string incluyendo los espacios. La sintaxis es la siguiente.

1	StringLen("string")

• string es la cadena de caracteres que se va a evaluar.
• Una expresión numérica se evalúa automáticamente y se convierte en un string.

Ejemplo: En un nuevo script que nombraremos StringLen, escribimos el siguiente código.

1
2
3

Local $iLongitud = StringLen("Hola Mundo.")

MsgBox(0,"Función StringLen","La longitud de esta cadena es: "&$iLongitud&" caracteres")

Al ejecutar el script nos debe mostrar la cantidad de caracteres que hay en el string incluyendo los espacios.

• StringLower: La función retorna una cadena de caracteres convertida en minúsculas. La sintaxis es la siguiente.

1	StringLower("string")

• string es la cadena que va a ser convertida.

Ejemplo: Creamos en un script con nombre StringLower y en ella escribamos las siguientes líneas de código.

1
2
3

Local $sStringLower = StringLower("HOLA MUNDO")

MsgBox(0,"Función StringLower",$sStringLower)

Corremos el script y nos de arrojar la palabra “HOLA MUNDO” convertida en minúscula.

• StringUpper: A diferencia de StringLower, esta función retorna una cadena de caracteres convertida en mayúsculas. La sintaxis es la siguiente.

1	StringUpper("string")

• string es la cadena de caracteres que será convertida.

Ejemplo: En un nuevo script que tendrá como nombre StringUpper, colocamos el siguiente código.

1
2
3

Local $sStringUpper = StringUpper("hola mundo")

MsgBox(0,"Función StringUpper",$sStringUpper)

Al correr el script, veremos que se muestra el string “hola mundo” convertida en mayúsculas.

• StringSplit: Divide una cadena en subcadenas según los delimitadores dados. La sintaxis de esta función es la siguiente.

1	StringSplit("string","deilimitadores"[,bandera=0])

• Los corchetes representan las opcionales de la sintaxis.
• string es la cadena que se va a evaluar.
• Los delimitadores son uno o más caracteres que se usan para limitar o dividir la cadena (mayúsculas y minúsculas).
• La bandera es opcional y cambia el funcionamiento de la división de la cadena, puede agregar varios valores de bandera si es necesario.
• La función StringSplit devuelve un arreglo en donde la posición cero contiene el número de cadenas retornadas, mientras que en las otras posiciones del arreglo contienen las cadenas que fueron delimitadas.
• Si se usa una cadena vacía “” para delimitar, cada carácter se devolverá como un elemento en cada posición del arreglo.

Ejemplo 1: Creemos un script con nombre StringSplit (1) y en ella escribamos el siguiente código.

1
2
3
4
5
6

Local $sHolaMundo = "Hola Mundo"
Local $aSSplit = StringSplit($sHolaMundo," ")

MsgBox(0,"Función StringSplit 1","No. cadenas: "&$aSSplit[0])
MsgBox(0,"Función StringSplit 1","Arreglo posición 1: "&$aSSplit[1])
MsgBox(0,"Función StringSplit 1","Arreglo posición 2: "&$aSSplit[2])

Lo que hace el código mostrado anteriormente es dividir la cadena “Hola Mundo” cuando encuentre un espacio en blanco. Luego en la línea 6 muestra lo que hay en la posición 0 del arreglo $aSSplit que de acuerdo con lo explicado anteriormente debería retornar el número de cadenas, en este caso son 2 (“Hola”, “Mundo”), en las líneas 7 y 8 se muestran los elementos que hay en las posiciones 1 y 2 del arreglo $aSSplit que serían “Hola” y “Mundo” respectivamente.

Ejemplo 2: Ahora verificaremos si cuando usamos una cadena vacía para delimitar, entonces cada carácter de esta cadena se devolverá en cada posición del arreglo. Entonces creamos un nuevo script que tendrá como nombre StringSplit (2) y en ella escribimos el siguiente código.

1
2
3
4

Local $sQVision = "QVision"
Local $aSplit = StringSplit($sQVision,"")

MsgBox(0,"StringSplit 2",$aSplit[1]&$aSplit[2]&$aSplit[3]&$aSplit[4]&$aSplit[5]&$aSplit[6]&$aSplit[7])

Cada una de las posiciones del arreglo $aSplit contendrá las letras de la cadena “QVision”. Ejecutamos el script y observaremos el siguiente resultado.

Nota: La posición 0 del arreglo $aSplit no se utilizó ya que contiene el número de subcadenas que se formaron al hacer la división de la cadena “QVision”, en este caso debería tener el valor de 7.

• StringReplace: La finalidad de esta función es reemplazar una subcadena que hay en una cadena por otra subcadena.

La sintaxis de esta función es la siguiente.

1	StringReplace("string","searchstring/start","replacestring"[,occurrence=0[,casesense=0]])

• Los corchetes representan las partes opcionales de la sintaxis.
• La función StringReplace retorna la nueva cadena junto al número de reemplazos realizados. Si quiere saber la cantidad de cambios que se hicieron utilice la macro @extended.
• string es la cadena que se va a evaluar.
• searchstring/start es la subcadena para buscar o la posición del carácter para para iniciar el reemplazo.
• replacestring es la cadena de reemplazo.
• occurrence es el número de veces para reemplazar la cadena de búsqueda. Use una ocurrencia negativa para reemplazar desde la derecha. El valor cero indica que todas las cadenas de búsqueda serán reemplazadas (es el valor por defecto).
• casesense es un marcador para indicar si las operaciones deben ser sensibles a mayúsculas y minúsculas. En este campo se pueden poner 3 valores:
1. $STR_NOCASESENSE (0) = No distingue entre mayúsculas y minúsculas, utilizando una configuración regional del usuario (este es el valor que viene por defecto).
2. $STR_CASESENSE (1) = Distingue entre mayúsculas y minúsculas.
3. $STR_NOCASESENSEBASIC (2) = No distingue entre mayúsculas y minúsculas, usando una comparación básica / más rápida.

Nota: Para utilizar las constantes globales $STR_NOCAESENSE, $STR_CASESENSE y $STR_NOCASESENSEBASIC debe incluir el archivo StringConstants.au3 usando la siguiente línea en el inicio del script #include <StringConstants.au3>.

Ejemplo: El script que vamos a crear tendrá como finalidad mostrar el uso de la función StringReplace en donde colocaremos un texto y reemplazaremos los espacios en blanco por guion (-). Luego mostraremos el nuevo texto resultante junto al número de reemplazos que se tuvieron que hacer.

El nombre que le pondremos a nuestro script será StringReplace y dentro de ella escribimos el siguiente código.

1
2
3
4
5

Local $sString = StringReplace("Esto es un párrafo con espacios en blanco"," ","-")
Local $iReemplazos = @extended ;Cantidad de reemplazos que se realizaron

MsgBox(0,"StringReplace","La nueva frase es: "&@CRLF&@CRLF&$sString)
MsgBox(0,"StringReplace","Cantidad de reemplazos hechos: "&$iReemplazos)

Al ejecutar el script obtendremos los siguientes resultados.

En el código anterior, la macro @CRLF es usado para dar saltos de líneas.