Funciones. Subrutinas y Procedimientos Asp Visual Basci
Funciones. Subrutinas y Procedimientos Asp Visual Basci
Funciones. Subrutinas y Procedimientos Asp Visual Basci
Subrutinas y
procedimientos
Índice
Descripción 1
Lección: Crear procedimientos 2
Lección: Uso de procedimientos 17
Lección: Uso de funciones predefinidas 33
Funciones. Subrutinas y procedimientos 1
Descripción
Crear Escribir
Debug
Código Crear procedimientos
Interfaz
and Deploy
Uso de Visual
Studio .NET
Uso de procedimientos
Uso de funciones
Acceso predefinidas
a datos Depurar e
Implantar
*************************************************************************************
Introducción El desarrollo de una aplicación, especialmente si se trata de un proyecto de gran
tamaño, es más fácil si se divide en piezas más pequeñas. El uso de
procedimientos puede ayudarnos a agrupar nuestro código en secciones lógicas
y condensar tareas repetidas o compartidas, como cálculos utilizados
frecuentemente. En este módulo, aprenderemos a crear y utilizar
procedimientos.
Objetivos En este módulo, aprenderemos a:
Diferenciar entre un procedimiento Sub y un procedimiento Function.
Crear e invocar procedimientos Sub y Function.
Escribir procedimientos en módulos para permitir la reutilización del
código.
Pasar argumentos por valor y por referencia.
Utilizar funciones predefinidas en el código de nuestra aplicación.
2 Funciones. Subrutinas y procedimientos
*************************************************************************************
Introducción Esta lección explica cómo crear procedimientos Sub y Function, cómo declarar
argumentos en un procedimiento y cómo crear procedimientos en un módulo.
Estructura de la lección Esta lección incluye los siguientes temas y actividades:
¿Qué son los procedimientos?
Cómo crear procedimientos Sub
Cómo crear procedimientos Function
Cómo declarar argumentos en procedimientos
Multimedia: pasar argumentos
Cómo utilizar argumentos opcionales
Multimedia: escribir código reutilizable
Reutilización de código
Práctica: crear una Función en un Módulo
*************************************************************************************
Definición Los procedimientos son las sentencias de código ejecutable de un programa.
Las instrucciones de un procedimiento están delimitadas por una instrucción de
declaración y una instrucción End.
Tipos de procedimientos Existen tres tipos de procedimientos en Microsoft Visual Basic® .NET:
procedimientos Sub, procedimientos Function y procedimientos Property.
Los procedimientos Sub realizan acciones pero no devuelven un valor al
procedimiento que origina la llamada. Los controladores de eventos son
procedimientos Sub que se ejecutan en respuesta a un evento.
Los procedimientos Function pueden devolver un valor al procedimiento
que origina la llamada. La instrucción MessageBox.Show es un ejemplo de
función.
Los procedimientos Property devuelven y asignan valores de propiedades
de clases, estructuras o módulos.
Uso de procedimientos Un procedimiento puede ser invocado, o llamado, desde otro procedimiento.
Cuando un procedimiento llama a otro procedimiento, se transfiere el control al
segundo procedimiento. Cuando finaliza la ejecución del código del segundo
procedimiento, éste devuelve el control al procedimiento que lo invocó.
Debido a esta funcionalidad, los procedimientos resultan útiles para realizar
tareas repetidas o compartidas. En lugar de escribir el mismo código más de una
vez, podemos escribir un procedimiento e invocarlo desde varios puntos de
nuestra aplicación o desde otras aplicaciones.
Accesibilidad del Utilizamos un modificador de acceso para definir la accesibilidad de los
procedimiento procedimientos que escribimos (es decir, el permiso para que otro código
invoque al procedimiento). Si no especificamos un modificador de acceso, los
procedimientos son declarados public de forma predeterminada.
La siguiente tabla muestra las opciones de accesibilidad para declarar un
procedimiento dentro de un módulo:
Modificador de Descripción
acceso
[accessibility]
[accessibility] Sub
Sub subname[(argumentlist)]
subname[(argumentlist)]
'' Sub
Sub procedimiento
procedimiento statements
statements
End
End Sub
Sub
Ejemplo:
Private
Private Sub
Sub AboutHelp(
AboutHelp( ))
MessageBox.Show("MyProgram
MessageBox.Show("MyProgram V1.0",
V1.0", "MyProgram
"MyProgram Help")
Help")
End
End Sub
Sub
*************************************************************************************
Definición Un procedimiento Sub es una serie de instrucciones de Visual Basic
delimitadas por las instrucciones Sub y End Sub. Los procedimientos Sub
realizan acciones pero no devuelven un valor al procedimiento que origina la
llamada.
Sintaxis para crear un Utilicemos la siguiente sintaxis para crear un procedimiento Sub:
procedimiento Sub
[accessibility] Sub subname[(argumentlist)]
' Statements of the Sub procedure go here
End Sub
Ejemplo de El siguiente código crea un procedimiento Sub (Sub AboutHelp) que utiliza un
procedimiento Sub cuadro de mensaje para mostrar un nombre de producto y un número de
versión:
Private Sub AboutHelp( )
MessageBox.Show("MyProgram V1.0", "MyProgram Help")
End Sub
6 Funciones. Subrutinas y procedimientos
Ejemplo:
Public
Public Function
Function DoubleTheValue(ByVal
DoubleTheValue(ByVal JJ As
As Double)
Double) As
As __
Double
Double
.. .. ..
Return
Return J*2
J*2
.. .. ..
End
End Function
Function
*************************************************************************************
Definición Un procedimiento Function es una serie de instrucciones Visual Basic
delimitadas por las instrucciones Function y End Function. Los
procedimientos Function son similares a los procedimientos Sub, pero las
funciones pueden devolver un valor al programa que origina la llamada.
Sintaxis para crear a Utilicemos la siguiente sintaxis para crear un procedimiento Function:
Function procedimiento
[accessibility] Function functionname[(argumentlist)] As _
datatype
' Statements of the function go here, including optional
' Return statement
End Function
Ejemplo de un El siguiente código crea una función denominada Square que devuelve el
procedimiento Function cuadrado de un número entero (integer):
Function Square(SquareValue As Integer) As Integer
Square = SquareValue * SquareValue
End Function
Valores de retorno El valor que devuelve un procedimiento Function al programa que origina la
llamada se denomina valor de retorno. La función devuelve el valor en una de
las dos formas siguientes:
Asigna un valor al nombre de su propia función en una o más instrucciones
dentro del procedimiento. El control no se devuelve al programa que origina
la llamada hasta que se ejecuta una instrucción Exit Function o End
Function.
La instrucción Exit Function provoca la salida inmediata de un
procedimiento Function. Cualquier número de instrucciones Exit Function
pueden aparecer en cualquier lugar del procedimiento.
Utiliza una instrucción Return para especificar el valor devuelto, y
devuelve el control inmediatamente al programa que origina la llamada.
Funciones. Subrutinas y procedimientos 7
Paso ByVal y ByRef Cuando definimos un procedimiento, definimos el modo en el que otros
procedimientos pueden pasar argumentos al procedimiento. Podemos escoger
pasarle argumentos por referencia (ByRef) o por valor (ByVal). En
Visual Basic .NET, el mecanismo predeterminado de paso de parámetros es por
valor. Si no especificamos ByVal ni ByRef en nuestras definiciones de
parámetros, ByVal se añade automáticamente a la definición del parámetro.
Mecanismo de
paso Explicación Implicaciones Ventaja
Por valor El procedimiento invocado Si el procedimiento invocado Protege la variable de
recibe una copia de los modifica la copia, el valor original ser cambiada por el
datos cuando es invocado. de la variable permanece intacto. procedimiento
Palabra clave: Cuando la ejecución retorna al invocado.
ByVal procedimiento de llamada, la
variable contiene el mismo valor
que tenía antes de que el valor se
pasara.
Por referencia El procedimiento invocado El procedimiento invocado puede El procedimiento
recibe una referencia a los modificar la variable directamente. invocado puede utilizar
datos originales (la Cuando la ejecución retorna al el argumento para
Palabra clave: dirección de los datos en procedimiento de llamada, la devolver un nuevo
ByRef memoria) cuando es variable contiene el valor valor al código de
invocado. modificado. llamada.
Declarar argumentos Utilizamos la misma sintaxis para declarar los argumentos para procedimientos
Sub y procedimientos Function. Declaramos cada argumento de un
procedimiento del mismo modo en que declaramos una variable, especificando
el nombre del argumento y el tipo de datos. También podemos especificar el
mecanismo de paso y si el argumento es opcional.
La sintaxis para cada argumento en la lista de argumentos de un procedimiento
es como sigue:
([ByVal|ByRef] [ParamArray] nombreargumento As datatype)
Ejemplo de declaración En el siguiente ejemplo, el procedimiento Sub Hello está diseñado para tomar
de un argumento un argumento Name de tipo String por valor desde un procedimiento de
llamada.
Public Sub Hello(ByVal Name As String)
MessageBox.Show("Hello, " & Name & "!")
End Sub
Ejemplo:
Function
Function Add
Add (ByVal
(ByVal value1
value1 As
As Integer,
Integer, ByVal
ByVal value2
value2 As
As __
Integer,
Integer, Optional
Optional ByVal
ByVal value3
value3 As
As Integer
Integer == 0)
0) As
As Integer
Integer
*************************************************************************************
Introducción Podemos especificar que el argumento de un procedimiento es opcional y no es
necesario proporcionarlo cuando el procedimiento es invocado. Esto ofrece
flexibilidad cuando nuestro procedimiento es invocado por otro procedimiento.
El usuario puede decidir proporcionar o no un argumento.
Declarar un argumento Los argumentos opcionales están indicados por la palabra clave Optional en la
opcional definición del procedimiento. Además, cuando declaramos un argumento
opcional, se aplican las siguientes reglas:
Debe especificarse un valor predeterminado para todos los argumentos
opcionales.
El valor predeterminado de un argumento opcional debe ser una expresión
constante.
Todos los argumentos que sigan a un argumento opcional en la definición
del procedimiento también deben ser opcionales.
Ejemplo de argumento El siguiente ejemplo contiene un error; recordemos que los argumentos que
opcional incorrecto siguen a un argumento opcional también deben ser opcionales.
Function Add(ByVal value1 As Integer, Optional ByVal _
value2 As Integer = 0, ByVal value3 As Integer) As Integer
' Causes an error
Reutilización de código
Use
Useun…
un…
un… Para…
Para…
Para… Ejemplos
Ejemplos
Size
Size
Estructura
Estructura Objetos
Objetosque
queno
nonecesitan
necesitanser
serextendidos
extendidos Point
Point
Conversión
Conversióndede
Módulo
Módulo Funciones
Funcionesde
deutilidad
utilidadyydatos
datosglobales
globales temperatura
temperatura
Extende
Extendeobjetos
objetosuuobjetos
objetosque
quenecesitan
necesitan Formularios
Formularios
Clase
Clase cleanup Botones
cleanup Botones
Crear un módulo:
[Public|Friend]
[Public|Friend] Module
Module ModuleName
ModuleName
.. .. ..
End
End Module
Module
*************************************************************************************
Introducción Uno de los procesos más importantes en la creación de una aplicación basada
en Visual Basic es diseñar código para su reutilización. El modo como
escribimos el código afecta a su reutilización.
Escribir código para Podemos escribir código para ser reutilizado, incluyendo procedimientos, en
reutilizar estructuras, módulos o clases. La siguiente tabla proporciona una descripción de
las situaciones en las que deberíamos escoger cada una de estas opciones:
Usar un(a)… para… Ejemplo
Escribir procedimientos El siguiente código muestra cómo podemos escribir un procedimiento en una
en una estructura estructura. Asumimos que las variables x, y y z del ejemplo ya han sido
declaradas.
Structure TableDimensions
Private legHeight, topWidth, topDepth As Integer
Public Sub New(ByVal legHeight As Integer, _
ByVal topWidth As Integer, ByVal topDepth as Integer)
Me.legHeight = x
Me.topWidth = y
Me.topDepth = z
End Sub
End Structure
Crear un módulo Para crear un módulo, añadimos primero un módulo a nuestro proyecto. A
continuación, escribimos las instrucciones del código que definen los datos y
procedimientos de nuestro módulo.
Accesibilidad de un Al igual que con los procedimientos y las variables, utilizamos los
módulo modificadores de acceso para definir la accesibilidad de un módulo. Si no
utilizamos un modificador de acceso, los módulos se declaran Friend de modo
predeterminado.
La siguiente tabla define los modificadores de acceso disponibles para un
módulo:
Modificador de Definición
acceso
Abrir un proyecto
*************************************************************************************
En esta práctica, añadirá un módulo a un proyecto y creará una función en el
módulo. La función tomará height y width como argumentos y devolverá
Area.
Nota Utilizará el código creado en esta práctica como código de inicio para la
práctica Utilización del valor devuelto de una función, que realizará más
adelante en este módulo.
Nota No podrá probar la función hasta que finalice la práctica Utilización del
valor devuelto de una función.
*************************************************************************************
Introducción Uno de los principales beneficios del uso eficaz de procedimientos es la
reutilización de código. Los procedimientos que creamos en un programa
pueden utilizarse en ese programa y en otros proyectos, frecuentemente con
poca o nula modificación. Los procedimientos son útiles para tareas repetidas o
compartidas, como cálculos utilizados frecuentemente.
Esta lección describe cómo utilizar procedimientos Sub y Function, cómo
utilizar la sintaxis ParamArray para pasar argumentos, y cómo modificar el
inicio de la aplicación para crear un procedimiento Sub Main.
Estructura de la lección Esta lección incluye los siguientes temas y actividades:
Cómo utilizar procedimientos Sub
Cómo utilizar procedimientos Function
Práctica: utilización del valor devuelto de una función
Cómo pasar matrices a procedimientos
Cómo crear un Sub Main
Práctica: crear un Sub Main
Public
Public Sub
Sub Hello(ByVal
Hello(ByVal name
name As
As String)
String)
MessageBox.Show("Hello
MessageBox.Show("Hello "" && name)
name)
End
End Sub
Sub
Sub
Sub Test(
Test( ))
Hello("John")
Hello("John")
End
End Sub
Sub
*************************************************************************************
Introducción Para utilizar un procedimiento Sub, lo invocamos desde otro procedimiento.
Flujo de código Cada vez que se invoca un procedimiento Sub, se ejecutan sus instrucciones,
empezando por la primera instrucción ejecutable después de la instrucción Sub
y finalizando con la primera instrucción End Sub, Exit Sub o Return
encontrada. Después de que el procedimiento Sub ejecute nuestro código,
devuelve la ejecución del programa a la línea de código que sigue a la línea que
invocó el procedimiento Sub.
Invocar un La sintaxis para invocar un procedimiento Sub es la siguiente:
procedimiento Sub
[Call] Subname [(Argumentlist)]
Ejemplo de uso de la También puede utilizar el siguiente código para realiza la misma tarea:
instrucción Call
Sub DataButton_Click(...)
Call SetData( )
End Sub
End Sub
3. Para visualizar el efecto de pasar una variable por referencia cuando invoca
un segundo procedimiento, añada las tres líneas de código siguientes al
procedimiento Hello:
a. Mostrar el valor actual de Name en un cuadro de texto.
b. Establecer el valor de la variable Name a Samantha.
c. Mostrar el nuevo valor de Name en un cuadro de texto.
Nuestro código debería tener un aspecto similar al siguiente:
Public Sub Hello(ByRef Name As String)
MessageBox.Show("Hello, " & Name & "!")
Name = "Samantha"
MessageBox.Show("Hello, " & Name & "!")
End Sub
Funciones. Subrutinas y procedimientos 21
Archivos de solución Los archivos de solución para esta práctica se encuentran en la carpeta
ByRefTest\Solution dentro del archivo practs04.zip.
22 Funciones. Subrutinas y procedimientos
*************************************************************************************
Introducción Un procedimiento Function se diferencia de un procedimiento Sub en que el
primero puede devolver un valor al procedimiento de llamada.
Invocar una función Invocamos un procedimiento Function incluyendo su nombre y sus argumentos
en el lado derecho de una instrucción de asignación o en una expresión. Piense
en la siguiente función, que convierte una temperatura en Fahrenheit a una
temperatura en Celsius.
Function FtoC(ByVal temperature As Single) As Single
' Convert Fahrenheit to Celsius
FtoC = (temperature - 32.0) * (5 / 9)
End Function
Flujo de código Cada vez que se invoca la función se ejecutan sus instrucciones, empezando por
la primera instrucción ejecutable tras la instrucción Function y finalizando con
la primera instrucción End Function, Exit Function o Return encontrada.
Funciones. Subrutinas y procedimientos 23
*************************************************************************************
En este ejercicio, crearemos una aplicación sencilla que calcula el área de un
rectángulo, dada su altura (height) y anchura (width).
En primer lugar, crearemos el interfaz de usuario para la aplicación. El usuario
escribirá valores para la altura y la anchura en dos cuadros de texto de un
formulario y hará clic en un botón para calcular el área del rectángulo en
función de las dimensiones introducidas. El resultado se mostrará como una
etiqueta en el formulario.
A continuación, escribiremos el código para la aplicación. Invocaremos a la
función Area que creamos en la primera práctica de este módulo (Crear una
función en un módulo), pasaremos argumentos a la función y devolveremos un
valor.
2. Ejecutar la aplicación.
3. Escribir valores numéricos en los cuadros de texto Height y Width.
4. Hacer clic en Button1 y verificar que aparece la respuesta esperada.
5. Cerrar la aplicación.
Archivos de solución Los archivos de solución para esta práctica están ubicados en la carpeta
FunctionReturnValue\Solution dentro del archivo practs04.zip.
Funciones. Subrutinas y procedimientos 25
*************************************************************************************
Introducción Podemos pasar matrices como argumentos a un procedimiento igual que otros
argumentos. Visual Basic .NET también proporciona la palabra clave
ParamArray para declarar una matriz de parámetros en la definición de
parámetros de un procedimiento.
Pasar matrices Podemos pasar matrices unidimensionales o multidimensionales a
procedimientos del mismo modo que pasamos otros argumentos.
El siguiente ejemplo muestra cómo pasar una matriz unidimensional a un
procedimiento:
Sub PassArray(ByVal testScores As Integer( ))
...
End Sub
Ejemplo de declaración El siguiente código muestra cómo podemos definir un procedimiento con una
ParamArray matriz de parámetros:
Sub StudentScores(ByVal name As String, ByVal ParamArray _
scores( ) As String)
' Statements for Sub procedure
End Sub
*************************************************************************************
Introducción Para abrir y cerrar una aplicación, la biblioteca de clases del .NET Framework
proporciona la clase Application. La clase Application proporciona métodos
(procedimientos) y propiedades para gestionar una aplicación, incluyendo
métodos para abrir y cerrar una aplicación, métodos para procesar mensajes de
Microsoft Windows®, y propiedades para obtener información sobre una
aplicación.
El procedimiento Sub Cuando creamos aplicaciones con la plantilla Aplicación para Windows en
Main Visual Basic .NET, Visual Basic crea automáticamente un procedimiento Sub
oculto denominado Sub Main para la clase Form. Este procedimiento se utiliza
como punto de inicio para nuestra aplicación.
Crear un nuevo Sub En el procedimiento Sub Main, Visual Basic .NET invoca el método
Main Application.Run para iniciar la aplicación. Podemos cambiar este
comportamiento creando nuestro propio Sub Main y convirtiéndolo en el
objeto de inicio. Podemos crear Sub Main en un módulo o en otra clase.
Después de crear un Sub Main, necesitamos hacer de este nuevo procedimiento
el objeto de inicio utilizando la ventana Propiedades.
Probar la aplicación
*************************************************************************************
En esta práctica, generaremos código para una aplicación formada por tres
formularios, y crearemos un Sub Main como objeto de inicio para el proyecto.
Ë Abrir el proyecto
• Abrir el proyecto MultipleForms.sln, ubicado en la carpeta
Forms\Starter dentro del archivo practs04.zip y familiaricémonos con los
formularios y los módulos del proyecto.
Ë Declarar variables
• Declarar las siguientes variables en el archivo de módulo Starter.
Nombre de la variable Modificador de acceso Tipo de datos
Ë Probar la aplicación
1. Ejecutar la aplicación. Hacer clic en Car Loan y en el botón Next.
Comprobar que se abre el formulario Car Loan.
2. Salir de la aplicación haciendo clic en el botón Close de la esquina superior
derecha del formulario.
3. Ejecutar de nuevo la aplicación. Hacer clic en Home Loan y en el botón
Next. Comprobar que se abre el formulario Home Loan.
4. Salir de la aplicación haciendo clic en el botón Done.
5. Ejecutar de nuevo la aplicación. Hacer clic en el botón Next sin pulsar en un
tipo de crédito (loan). Comprobar si aparece un cuadro de mensaje
indicando al usuario que seleccione un tipo de crédito (loan).
6. Salir de la aplicación utilizando el botón Exit del formulario Selection.
Archivos de solución Los archivos de solución para esta práctica están ubicados en
Forms\Solution dentro del archivo practs04.zip.
Funciones. Subrutinas y procedimientos 33
*************************************************************************************
Introducción La biblioteca del entorno de ejecución de Visual Basic proporciona numerosas
funciones predefinidas que podemos utilizar en nuestro código. Estas funciones
se invocan del mismo modo en que invocamos a nuestras propias funciones.
En este módulo, estudiaremos la función InputBox, las funciones de fecha y
hora, las funciones de cadena, las funciones de formato y las funciones
financieras. En “Miembros de la biblioteca del entorno de ejecución de
Visual Basic”, en la documentación de Visual Studio .NET, encontraremos una
lista completa de las funciones predefinidas.
Estructura de la lección Esta lección incluye los siguientes temas y actividades:
Cómo utilizar la función InputBox
Cómo utilizar las funciones Date y Time
Cómo utilizar las funciones String
Cómo utilizar las funciones Format
Cómo utilizar las funciones Financial
Práctica: Examen de funciones predefinidas
*************************************************************************************
Introducción La función InputBox es una función predefinida que proporciona una forma
sencilla de interactuar con los usuarios. La función InputBox muestra un
cuadro de diálogo con un mensaje, espera a que el usuario introduzca texto o
haga clic en un botón y devuelve una cadena con el contenido del cuadro de
texto.
Parámetros La siguiente declaración de función muestra los parámetros de la función
InputBox:
Public Function InputBox(ByVal Prompt As String, _
Optional ByVal Title As String = "", _
Optional ByVal DefaultResponse As String = "", _
Optional ByVal XPos As Integer = -1, _
Optional ByVal YPos As Integer = -1 ) As String
Como podemos ver, los argumentos Title, DefaultResponse, XPos e YPos son
opcionales. La siguiente tabla explica los valores predeterminados que se
aplicarían en caso de escoger no pasar uno de estos argumentos opcionales a la
función InputBox.
Parámetro Definición Valor predeterminado
Ejemplo de utilización El siguiente código crea un cuadro de entrada con el título Search, que solicita
de la función InputBox al usuario que introduzca un nombre de archivo y almacena la respuesta del
usuario en una variable denominada FileName.
Dim FileName As String
FileName = InputBox("Please enter file name", "Search")
*************************************************************************************
Introducción Visual Basic proporciona numerosas funciones de fecha y hora que podemos
utilizar en nuestras aplicaciones. En esta sección, estudiaremos cómo utilizar
dos funciones predefinidas para realizar cálculos y operaciones que implican
fechas y horas.
Uso de la función Podemos utilizar la función DateAdd para añadir o sustraer un intervalo de
DateAdd tiempo específico a una fecha. Pasamos a la función la fecha y la información
sobre el intervalo, y la función DateAdd devuelve un valor Date que contiene
el valor de fecha y hora, al que se ha añadido o sustraído un intervalo de tiempo
especificado.
Parámetros La función DateAdd tiene tres parámetros, ninguno de ellos opcional, que se
muestran en la siguiente tabla:
Parámetro Definición
Ejemplo de utilización El siguiente código utiliza la función DateAdd para calcular la fecha de
de la función DateAdd vencimiento de una factura a partir de la fecha de facturación. En este
escenario, la fecha de vencimiento de la factura es 20 días después de la fecha
de factura. Por tanto, Interval es DateInterval.Day y Number es 20.
Funciones. Subrutinas y procedimientos 37
fechaFactura = #12/31/2000#
DateAdd(DateInterval.Day, 20, fechaFactura)
Utilización de la función Podemos utilizar la función DateDiff para determinar cuántos intervalos de
DateDiff tiempo especificados existen entre dos valores de fecha/hora. Por ejemplo,
podría utilizarse DateDiff para calcular el número de días entre dos fechas o el
número de semanas ente hoy y final del año.
Parámetros La función DateDiff tiene cinco parámetros, dos de los cuales son opcionales.
Estos parámetros se muestran en la tabla siguiente:
Parámetro Definición
Ejemplo de utilización Este ejemplo utiliza la función DateDiff para mostrar el número de días entre
de la función DateDiff una fecha determinada y la fecha actual.
Dim firstDate, msg As String
Dim secondDate As Date
' Declare variables
firstDate = InputBox("Enter a date")
' Get a given date from the user
secondDate = CDate(firstDate)
msg = "Days from today: " & DateDiff(DateInterval.Day, Now, _
secondDate)
MessageBox.Show(msg)
' Create a message box which uses the DateDiff function and
' displays the number of days between a given date and the
' current date
z Len
Length
Length == Len(customerName)
Len(customerName)
z Left
Microsoft.VisualBasic.Left(customerName,
Microsoft.VisualBasic.Left(customerName, 5)
5)
*************************************************************************************
Introducción En muchos casos, las cadenas (strings) requieren algún tipo de manipulación,
formateo o evaluación. Por ejemplo, el nombre de una persona puede escribirse
con el apellido delante del nombre de pila, o un archivo puede contener campos
separados por comas. Las funciones String de Visual Basic pueden analizar y
manipular cadenas en las aplicaciones. Estas funciones se utilizan para devolver
información sobre una cadena, extraer únicamente una parte de la cadena, o
mostrar información en un determinado formato.
Uso de la función Trim Podemos utilizar la función Trim para eliminar los espacios iniciales y finales
de una cadena específica.
Ejemplo de utilización El siguiente ejemplo muestra cómo utilizar la función Trim para devolver una
de Trim cadena que contenga una copia de una cadena específica sin espacios iniciales
ni finales:
Dim MyString, NewString As String
' Initialize string
MyString = " 1234 Street "
' NewString = "1234 Street"
NewString = Trim(MyString)
Uso de la función Len La función Len puede utilizarse para encontrar el número de caracteres de una
cadena o el número de bytes necesarios para almacenar una variable.
El siguiente código muestra la declaración para la función Len. El parámetro
Expression de esta declaración es cualquier expresión de cadena o nombre de
variable válidos.
Public Shared Function Len(ByVal Expression As datatype) As _
Integer
Funciones. Subrutinas y procedimientos 39
Ejemplo de utilización En el siguiente código, la función Len devuelve el número de caracteres de una
de Len cadena:
Dim customerName As string
Dim length As Integer
customerName = InputBox("What is your name?")
length = Len(customerName)
Uso de la función Left Podemos utilizar la función Left para devolver un número especificado de
caracteres desde el lado izquierdo de una cadena.
El siguiente código muestra la declaración de función para la función Left. El
parámetro Str de esta declaración es la expresión de cadena de la que la función
devolverá los caracteres más a la izquierda. El parámetro Length es un entero
que indica cuántos caracteres devolver.
Public Shared Function Left(ByVal Str As String, _
ByVal Length As Integer) As String
Ejemplo de utilización En el siguiente código, la función Left devuelve cinco caracteres del lado
de Left izquierdo de una cadena:
Microsoft.VisualBasic.Left(customerName, 5)
Ejemplo de utilización En el siguiente código, las funciones Len y Left se utilizan juntos para eliminar
de Len y Left la extensión del nombre del archivo (los cuatro últimos caracteres) de un
nombre de archivo:
fileName = Left(fileName, Len(fileName) - 4)
z FormatDateTime
FormatDateTime(myDate,
FormatDateTime(myDate, DateFormat.LongDate)
DateFormat.LongDate)
*************************************************************************************
Introducción Existen varios formatos aceptados universalmente para números, fechas y
horas. Visual Basic ofrece una gran flexibilidad en visualizar formatos de
números además de formatos de fecha y hora. Un beneficio añadido es que los
formatos regionales para números, fechas y horas se presentan fácilmente sin
codificar nuevamente para cada nacionalidad o región.
En esta sección, estudiaremos cómo utilizar dos funciones predefinidas para
formatear.
Uso de la función La función FormatCurrency puede utilizarse para devolver una expresión con
FormatCurrency formato de moneda que utiliza el símbolo de moneda definido en el panel de
control del sistema. Por ejemplo, se puede utilizar FormatCurrency para
formatear el importe debido en una factura.
Parámetros La función FormatCurrency tiene cinco parámetros, cuatro de los cuales son
opcionales. Cuando se omite uno o más argumentos opcionales, se utilizan
valores que se ajustan a la configuración regional predeterminada del equipo.
La siguiente tabla describe los parámetros de la función FormatCurrency:
Parámetro Definición
(continuación)
Parámetro Definición
Ejemplo de utilización El siguiente ejemplo utiliza la función FormatCurrency para formatear una
de la función cadena que representa importeDebido:
FormatCurrency
Dim importeDebido As Double = 4456.43
Dim myString As String
myString = FormatCurrency(importeDebido, , , TriState.True, _
TriState.True)
Uso de la función La función FormatDateTime puede utilizarse para formatear una expresión
FormatDateTime como fecha u hora. Por ejemplo, podemos utilizar FormatDateTime para
cambiar la expresión 5/21/01 por la expresión Monday, May 21, 2001.
Parámetros La función FormatDateTime tiene dos parámetros, como se muestra en la
siguiente tabla:
Parámetro Definición
DateFormat.GeneralDate Muestra una fecha y/u hora. Si hay una fecha, la presenta
como fecha corta. Si hay una hora, la presenta en formato
largo. Si las dos partes están presentes, se muestran
ambas.
DateFormat.LongDate Muestra una fecha en el formato largo especificado en la
configuración regional del equipo.
DateFormat.ShortDate Muestra una fecha en el formato corto especificado en la
configuración regional del equipo.
DateFormat.LongTime Muestra una hora en el formato de hora especificado en la
configuración regional del equipo.
DateFormat.ShortTime Muestra una hora en el formato de 24 horas (hh:mm).
z Rate
ratePerPeriod
ratePerPeriod == Rate(24,
Rate(24, 228,
228, -5000,
-5000, 0,
0, DueDate.BegOfPeriod,
DueDate.BegOfPeriod, __
0.8)*100
0.8)*100
*************************************************************************************
Introducción Visual Basic ofrece varias funciones financieras que podemos utilizar en
nuestras aplicaciones. En esta sección, estudiaremos cómo utilizar dos
funciones predefinidas para realizar cálculos y operaciones que implican dinero.
Uso de la función Pmt Podemos utilizar la función Pmt para calcular el pago de una anualidad basado
en pagos fijos periódicos y un tipo de interés fijo. Una anualidad es una serie de
pagos fijos que se realizan durante un periodo de tiempo, como una hipoteca
sobre una casa o el pago de un crédito para la compra de un coche.
Parámetros La función Pmt tiene cinco parámetros, dos de los cuales son opcionales. Para
todos los argumentos, el efectivo abonado (como depósitos de ahorro) se
representa con números negativos. El efectivo recibido (como cheques de
dividendos) se representa con números positivos. La siguiente tabla describe los
cinco parámetros de la función Pmt.
Parámetro Definición
(continuación)
Parámetro Definición
FV Valor futuro, o saldo, que se desea tener una vez realizado el pago final,
(Opcional) expresado como Double.
El valor predeterminado, si no se expresa ningún otro, es 0.
Due Indica cuándo vencen los pagos. Puede ser al final del periodo
(Opcional) (especificado comos DueDate.EndOfPeriod) o al principio del periodo
(especificado como DueDate.BegOfPeriod).
El valor predeterminado, si no se expresa ningún otro, es
DueDate.EndOfPeriod.
Ejemplo de utilización El siguiente código utiliza la función Pmt para calcular el pago mensual de un
de la función Pmt crédito de 24 meses de 5000 dólares al 10% TAE.
payment = Pmt(0.0083, 24, -5000, 0, DueDate.BegOfPeriod)
Uso de la función Rate La función Rate puede utilizarse para calcular el tipo de interés por periodo de
una anualidad.
Parámetros La función Rate tiene los mismos parámetros que la función Pmt, con las
siguientes excepciones:
Toma un argumento Pmt en lugar de un argumento Rate. Pmt es un
argumento obligatorio que representa el pago que debe realizarse cada
periodo y se expresa como Double.
Toma un argumento Guess opcional. Es el valor estimado que será devuelto
por Rate, expresado como Double. El valor predeterminado, si no se
expresa ningún otro, es 0.1 (10 por ciento).
Ejemplo de utilización El siguiente código utiliza la función Rate para calcular el tipo de interés por
de la función Rate periodo de un crédito de 24 meses de 5000 dólares con pagos mensuales de 228
dólares.
ratePerPeriod = Rate(24, 228, -5000, 0, DueDate.BegOfPeriod, _
0.8)*100
*************************************************************************************
En esta práctica, utilizaremos la documentación de Visual Studio para estudiar
las funciones predefinidas y cómo utilizarlas en nuestro código.
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
Funciones. Subrutinas y procedimientos 47
subString = Microsoft.VisualBasic.Right(myString, 3)
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________