OpenEdge ABL: Cómo definir variables y constantes

 

En otras publicaciones ya hemos hablado de éste lenguaje de programación. Sin embargo, faltó indicar indicar cómo se declaran las variables y constantes, además de como se puede asignar valores a ellas. En el post anterior vimos que podemos asignar valores con la palabra ``ASSIGN``, pero podemos omitirla. También vimos como iniciar un valor con la palabra ``INIT``.

DEFINE VARIABLE edad AS INTEGER NO-UNDO.

/* Usando la palabra clave ASSIGN */
ASSIGN edad = 30.

/* Usando el operador de asignación = */
edad = 30.

Podemos usar ``ASSIGN`` para asignar valores a las variables declaradas.

DEFINE VARIABLE RADIO AS DECIMAL NO-UNDO INITIAL 5.0.

DEFINE VARIABLE AREA AS DECIMAL NO-UNDO.

/* Declaración de la constante */
DEFINE VARIABLE PI AS DECIMAL NO-UNDO INITIAL 3.14159.

/* Cálculo del área del círculo */
AREA = PI * RADIO * RADIO.

/* Mostrar el área */
MESSAGE "El área del círculo es: " AREA VIEW-AS ALERT-BOX.

Podemos usar ``INITIAL`` para inicializar un valor en una variable y omitir ``ASSIGN``. Y también usamos la palabra ``INITIAL`` para inicializarla. En teoría una constante es una variable que no podrá cambiar de valor a lo largo del flujo del programa. En OpenEdge para declara una constante deberás usar una clase y dentro de ésta crear un campo público e inicializar el valor. Algo bastante engorroso. Aquí en este post solo simulamos crearla.

En OpenEdge existen variables de tipo:

CHAR o CHARACTER
DATE
INT o INTEGER
DEC o DECIMAL
LOGICAL

Ejemplos de declaración de variables y asignación de valores.

/* Declaración de variables */
DEFINE VARIABLE cliente AS HANDLE NO-UNDO.
DEFINE VARIABLE fechaNacimiento AS DATE NO-UNDO.
DEFINE VARIABLE esMayorDeEdad AS LOGICAL NO-UNDO.
DEFINE VARIABLE nombre AS CHARACTER NO-UNDO.
DEFINE VARIABLE precio AS DECIMAL NO-UNDO.
DEFINE VARIABLE edad AS INTEGER NO-UNDO.

/* Asignación de valores */
ASSIGN edad = 30.
ASSIGN precio = 19.99.
ASSIGN nombre = "Juan".
ASSIGN esMayorDeEdad = TRUE.
ASSIGN fechaNacimiento = DATE("1990-01-01").

CREATE CLIENTE.
ASSIGN cliente = LAST-RESULT.

Hemos aprendido cómo declarar variables y constantes en OpenEdge.

Enlaces:

https://codemonkeyjunior.blogspot.com/2024/03/openedge-abl-creando-funciones-y.html

OpenEdge ABL: creando funciones y procedimientos

Crear nuestras propias funciones o procedimientos nos sirve para la reducción de código y hacer el código más legible. Pero antes de comenzar, debemos hacer una diferencia: las funciones nos devolverán valores y los procedimientos no.

Ejemplo. Se requiere crear una función que convierta grados Celsius a grados Fahrenheit. Fórmula:

F = (9/5 * Celsius) + 32

fahrenheit.p

def var celsius as dec no-undo initial 33.9.

/* Función para realizar la conversión de Celsius a Fahrenheit */
function getFahrenheit dec(valor as dec):
    return (9.0 / 5.0) * valor + 32.0.
end.

display "Celsius: " celsius " , Fahrenheit: " getFahrenheit(celsius).

Nota: Para probar este código puedes entrar a este sitio: https://abldojo.services.progress.com/

Para que el programa funcione, se debe crear primero la función. Recordemos que muchos lenguajes de pogramación hacen una evaluación Top-down. Si invocas una función en el bloque de arriba sin antes definir una función, causará error.

También podríamos agregar otra función que obtenga lo grados Celsius:

/* Función para obtener grados Celsius */
function getCelsius dec (valor as dec):
    return (valor - 32.0) / (1.8).
end function.

También podríamos escribir la misma función pero de esta manera:

FUNCTION getCelsius RETURNS DECIMAL (
    INPUT valor AS DECIMAL
):
    DEFINE VARIABLE celsius AS DECIMAL.
    
    ASSIGN
        celsius = (valor - 32.0) * (5.0 / 9.0).
        
    RETURN celsius.
END FUNCTION.

Código completo:

def var celsius as dec no-undo initial 33.9.

/* Función para realizar la conversión de Celsius a Fahrenheit */
function getFahrenheit dec(valor as dec):
    return (9.0 / 5.0) * valor + 32.0.
end.

FUNCTION getCelsius RETURNS DECIMAL (
    INPUT valor AS DECIMAL
):
    DEFINE VARIABLE celsius AS DECIMAL.
    
    ASSIGN
        celsius = (valor - 32.0) * (5.0 / 9.0).
        
    RETURN celsius.
END FUNCTION.

display "Celsius: " celsius " , Fahrenheit: " getFahrenheit(celsius).
display "Celsius: " getCelsius(getFahrenheit(celsius)).

Como se pude ver usamos ``ASSIGN`` para asignar valores. En este caso asignamos el resultado de la conversión a la variable ``celsius``. El resultado será:

   celsius
          ----------
Celsius:       33.90  , Fahrenheit:       93.02 Celsius:       33.90

Para realizar la conversión de grados Fahrenheit a Celsius usamos ésta fórmula:

Celsius = (valor - 32.0) * (5.0 / 9.0).

Ejemplo 2. Crear un procedimiento que solo imprima un simple "Hola, mundo".

PROCEDURE imprimirHolaMundo():
    MESSAGE "Hola, mundo" VIEW-AS ALERT-BOX.
END PROCEDURE.

Para invocarlo:

RUN imprimirHolaMundo.

Ejemplo 3. Crear una función que no necesite parámetros de entrada.

FUNCTION getSaludo RETURNS CHARACTER:
    RETURN "Hola, programador de OpenEdge".
END FUNCTION.

DISPLAY getSaludo().

Ejemplo 4. Crear una función que calcule el factorial de un número

FUNCTION calcularFactorial RETURNS DECIMAL (
    INPUT numero AS DECIMAL
):
    DEFINE VARIABLE resultado AS DECIMAL INIT 1.
    DEFINE VARIABLE contador AS DECIMAL.
    
    DO contador = 1 TO numero:
        resultado = resultado * contador.
    END.
    
    RETURN resultado.
END FUNCTION.

DISPLAY calcularFactorial(5).

En este caso el resultado será: 120.00

Podríamos modificar la función usando la técnica de recursión:

FUNCTION calcularFactorial RETURNS DECIMAL (
    INPUT numero AS DECIMAL
):
    IF numero = 0 THEN
       RETURN 1.
    ELSE
       RETURN numero * calcularFactorial(numero - 1).
END FUNCTION.

DISPLAY calcularFactorial(5).

Ambas funciones resuelven el mismo problema. Como se ha visto en los primeros ejemplos: OpenEdge nos permite algunas cosas como omitir colocar la palabra ``INPUT`` o no colocar la palabra ``FUNCTION`` al final de una función.

Más ejemplos en próximas entregas.

Enlaces:

https://www.progresstalk.com/
https://abldojo.services.progress.com/

OpenEdge: Progress ABL (Advanced Business Language)

Progress ABL es un lenguaje de programación vinculado al entorno Progress OpenEdge, su base de datos y las utilidades que lo rodean. 

Es similar al inglés fuertemente tipado, enlazado en tiempo de ejecución. Aunque inicialmente se diseñó como un lenguaje procedimental, a partir de la versión 10.1 se mejoró con elementos de gramática orientada a objetos, que se pueden mezclar con el estilo procedimental original. 

A diferencia de otros lenguajes, Advanced Business Language (ABL) permite a los desarrolladores administrar datos relacionales de la manera que mejor se adapte a sus necesidades comerciales, lo que aumenta significativamente la productividad. 

Un desarrollador de OpenEdge puede crear API para .NET, JavaScript, clientes Java, mensajería Java e incluso asignar esquemas de bases de datos a formatos XML, al mismo tiempo que aprovecha la eficiencia de ABL. 

ABL también ofrece herramientas esenciales para el desarrollo de aplicaciones, lo que le permite tener fácil acceso a todos los recursos de su aplicación.

¿Por qué %$@# debería importarme este lenguaje?

Porque en el mundo de la informática siempre hay que saber un poco de todo. Un día eres programador Java, mañana tendrás que usar PHP, C, etc. Pasar del Backend al Frontend y hasta a BD. Siempre hay que estar abiertos a todo. 

Imaginemos un escenario donde una empresa usa Progress y decide contratar a un nuevo desarrollador para trasladar los códigos de Progress a Java, o viceversa. El desarrollador con experiencia en Progress tendrá menos dificultad de trasladar ese código a Java pues conoce lo que hacen y no hacen esos programas.

Crear un programa en Progress es relativamente sencillo si tienes experiencia en lenguajes como Perl o Python. El programa para calcular el factorial de un número podría ser algo como esto:

factorial.p

function factorial returns integer (num as integer):
   if num = 0 then
      return 1.
   else
      return num * factorial(num - 1).
end.

DISPLAY "Factorial de 5: " factorial(5).

Un programa en Progress tiene la extensión *.p. Los tipos básicos son: integer, decimal, character y logical (boolean). Las estructuras de control son similares a las de Perl y/o Python. Además de que es de tipado estático. Tendrás que declarar el tipo y valor antes de usar una variable.

/* Puedes usar def o define, var o variable */
define var numero as integer no-undo. /*  int */
def variable valor as dec no-undo. /*  decimal */
def var verdadero as logical no-undo. /*  booleano */
def cadena valor as char no-undo. /*  character*/

Podemos hacer cualquier cosa como en otros lenguajes.

longitud.p

def var cadena as char no-undo.
def var longitud as int no-undo.

cadena = TRIM(" ABC "). /* quitar espacios */
longitud = LENGTH(cadena). /* Contar longitud de la cadena */

display "Cadena: " cadena " , Longitud: " longitud.

Aquí podemos observar que posee funciones propias para la manipulación de cadenas.

¿Y qué con las BD?

Crear programas para la manipulación o consulta de datos es tan fácil como esto:

for each empleados:
    display empleados.idEmp empleados.nomEmp empleados.idDepto
end.

Mientras que en código Java como mínimo tendrías que crear un proyecto. Hacer la conexión y la consulta SQL. Sin olvidar lo engorroso que es encontrar un driver para la BD.

Para probar Progress Online puedes entrar aquí: https://abldojo.services.progress.com/

Más sobre este lenguaje en próximos posts.

Enlaces:

https://www.progresstalk.com/
https://www.progress.com/