Bloque de código

El bloque de código es un usuario o sección de código con una o más declaraciones y sentencias. Un lenguaje de programación que permite bloques, incluyendo bloques anidados dentro de otros bloques es llamado un lenguaje de programación estructurado por bloques.

Ideas de la estructura del bloque se desarrollaron en la década de los años 1950, durante el desarrollo de los primeros autocodes y fueron formalizados en los informes de Algol 58 y Algol 60. Algol 58 introdujo la noción de la "sentencia compuesta", que estaba relacionada únicamente con control de flujo.^[1] El posterior informe revisado que describe la sintaxis y la semántica de Algol 60 introdujo la noción de un bloque, consistiendo en "una secuencia de sentencias encerrada entre begin y end..." en la que "cada declaración aparece en un bloque de esta manera y es válida solo para ese bloque".^[2]

La función de los bloques de programación es permitir que grupos sentencias sean tratados como si fueran una sola sentencia, y restringir el ámbito léxico de las variables, los procedimientos y funciones declaradas en un bloque para que no entre en conflicto con variables con el mismo nombre utilizadas para diferentes propósitos en otras partes de un programa.

La noción de bloques es introducida por diferentes sintaxis en diferentes lenguajes, pero hay dos grandes familias: la familia del ALGOL en que los bloques están delimitados por las palabras clave begin y end, y la familia de C en la que los bloques están delimitados por llaves { y }. Algunas otras técnicas utilizadas son el uso de sangría, y s-expression con una palabra clave sintáctica como lambda o let (como en la familia del Lisp).

En un lenguaje de programación estructurado en bloque, los nombres de las variables y otros objetos, como los procedimientos que son declarados en bloques externos son visibles dentro de otros bloques internos, a menos que sean sombreado por un objeto del mismo nombre.

Algunos lenguajes que soportan bloques con declaraciones de variables no soportan completamente todas las declaraciones; por ejemplo muchos lenguajes derivados de C no permitan la definición de una función dentro de un bloque. Y a diferencia de su antecesor Algol, Pascal no soporta el uso de bloques con sus propias declaraciones dentro del begin y end de un bloque existente, sólo sentencias compuestas permitiendo una secuencia de declaraciones agrupadas en if, while, repeat y otras sentencias de control.

Origen

Con la aparición de miniprocesadores más potentes, la programación planificada pierde sus fundamentos en favor de la programación de sistemas dirigidos por datos. Esto marca el final del uso de la programación monolítica gobernada por Assembler, C, Pascal y fundamentalmente COBOL. Con la liberación de su Clipper versión 5.0, (en 1990) Nantucket proporciona un nuevo tipo de datos al cual llamó CodeBlock. Este nace de la necesidad de suprimir el uso de macroinstrucciones o macrosubstituciones. Estas macroinstrucciones o macrosubstituciones también se abreviaron para pasar a llamarse simplemente "macros". En la actualidad existen otros lenguajes de programación que encontraron útiles la definición y conceptos subyacentes en el término CodeBlock.

Sintaxis

 bBloqueDeCodigo:= { | <ListaDeParametros,...> | Código Clipper Ejecutable }

Uso

Sea un arreglo con datos, el recorrido iterativo del mismo se produce con la instrucción AEVAL(), la cual posee la sintaxis:

 AEval( <aArreglo>, <bBloqueDeCodigo>, [<nInicio>], [<nCantidad>], [<lAsignar>] ) --> aArreglo

Parámetros

 <aArreglo> es un arreglo cuyos elementos se pasan al bloque de código.

 <bBloqueDeCodigo> es un bloque de código que se ejecuta para cada elemento del arreglo.

 <nInicio> es un valor numérico especificando el primer elemento del arreglo <aArreglo> para elcual el bloque de código se ejecutará. El valor predeterminado es 1.

 <nCantidad> es un valor numérico indicando el número de elementos pasados al bloque de código comenzando desde la posición <nInicio>. Si falta <nCantidad>, se pasarán al bloque de código secuencialmente todos los elementos desde <nInicio> hasta el último del <aArreglo>.

 La expresión lógica <lAsignar> determina cuando se permitirá una asignación dentro del bloque de código. Si <lAsignar> es Verdadero (.T.), el elemento del arreglo se pasa por referencia. Si se realiza una asignación en el bloque de código, esta se reflejará en el correspondiente elemento del arreglo.

Sea una porción de código ejecutable agrupado en una rutina llamada "Procedimiento()".

 PROCEDURE Procedimiento()
   LOCAL nEleccion
   LOCAL aAcciones = {;
                      { || Altas() },;
                      { || Bajas() },;
                      { || Modificaciones() },;
                      { || nEleccion:= 0 };
                     }
   nEleccion:= -1
   WHILE nEleccion <> 0 
      @ 10, 10 PROMPT "Altas" 
      @ 11, 10 PROMPT "Bajas" 
      @ 12, 10 PROMPT "Modificaciones"
      @ 13, 10 PROMPT "Salir"  
      MENU TO nEleccion
      IF nEleccion > 0
         EVAL( aAcciones[nEleccion] )         
      ENDIF
   ENDDO
 RETURN

En el ejemplo dado, el ciclo WHILE...ENDDO será cerrado mientras el usuario no realice elección alguna.
Si el usuario presiona la tecla ESC, nElección será asignado con un 0 y el ciclo se romperá.
Cuando el usuario elija alguno de los elementos del menú entonces nEleccion será distinto de cero pero tendrá un valor entre 1 y 4.
En ese caso será evaluada positivamente la comparación nEleccion > 0 y será evaluado el bloque de código almacenado en el arreglo aAcciones.
Préstese especial atención al último elemento de aAcciones, el cual implica una asignación en tiempo de ejecución.
Esa asignación produce la ruptura del ciclo.

Uso

  Eval( <bBloqueDeCodigo>, [<ListaDeExpresiones,...>]) --> xUltimoValor

Parámetros

  <bBloqueDeCodigo> es un bloque de código que se ejecutará.

<ListaDeExpresiones,...>

  <ListaDeExpresiones,...> es una lista de expresiones cuyos valores serán pasados al Bloque de Código como parámetros.

Beneficios

Los Bloques de Código son el intento de substituto de las macroinstrucciones de Clipper. Las macros tienen fundamento de existencia en la necesidad de crear variables dinámicamente, construir expresiones regulares y ejecutarlas en tiempo de ejecución.

Consecuencias

Esa posibilidad, sobreexplotada, ocasiona una gran carga en los mantenimientos de los sistemas desarrollados con estas macros debido a que ocultan las fallas en tiempo de desarrollo y detonan en tiempo de ejecución, en el ambiente del usuario final. Generalmente las macros son preferidas para el desarrollo de aplicaciones con escasa o nula planificación.

Referencias

↑ Perlis, A.J.; Samelson, K. (1958). «Preliminary report: international algebraic language». Communications of the ACM 1 (12): 8-22. doi:10.1145/377924.594925.
↑ Backus, J. W.; Bauer, F. L.; Green, J.; Katz, C.; McCarthy, J.; Perlis, A. J.; Rutishauser, H.; Samelson, K.; Vauquois, B.; Wegstein, J. H.; van Wijngaarden, A.; Woodger, M. (mayo de 1960). Naur, Peter, ed. Report on the Algorithmic Language ALGOL 60. Copenhagen. ISSN 0001-0782. doi:10.1145/367236.367262. Consultado el 27 de octubre de 2009.

Enlaces externos

Datos: Q1327579

[algol58_report-1] Perlis, A.J.; Samelson, K. (1958). «Preliminary report: international algebraic language». Communications of the ACM 1 (12): 8-22. doi:10.1145/377924.594925.

[algol60_report-2] Backus, J. W.; Bauer, F. L.; Green, J.; Katz, C.; McCarthy, J.; Perlis, A. J.; Rutishauser, H.; Samelson, K.; Vauquois, B.; Wegstein, J. H.; van Wijngaarden, A.; Woodger, M. (mayo de 1960). Naur, Peter, ed. Report on the Algorithmic Language ALGOL 60. Copenhagen. ISSN 0001-0782. doi:10.1145/367236.367262. Consultado el 27 de octubre de 2009.

[1]

[2]