Bloque (programación) - Block (programming)
En programación de computadoras , un bloque o bloque de código o bloque de código es una estructura léxica de código fuente que se agrupa. Los bloques constan de una o más declaraciones y sentencias . Un lenguaje de programación que permite la creación de bloques, incluidos los bloques anidados dentro de otros bloques, se denomina lenguaje de programación estructurado por bloques . Los bloques son fundamentales para la programación estructurada , donde las estructuras de control se forman a partir de bloques.
Los bloques tienen dos funciones: agrupar declaraciones para que puedan tratarse como una sola declaración; y definir el alcance de los nombres para distinguirlos del mismo nombre utilizado en otros lugares. En un lenguaje de programación estructurado por bloques, los objetos nombrados en los bloques externos son visibles dentro de los bloques internos, a menos que estén enmascarados por un objeto declarado con el mismo nombre.
Historia
Las ideas de estructura de bloques se desarrollaron en la década de 1950 durante el desarrollo de los primeros códigos automáticos y se formalizaron en los informes Algol 58 y Algol 60 . Algol 58 introdujo la noción de "declaración compuesta", que estaba relacionada únicamente con el control del flujo . El informe revisado posterior que describió la sintaxis y la semántica de Algol 60 introdujo la noción de bloque y alcance de bloque , con un bloque que consta de "Una secuencia de declaraciones seguida de una secuencia de declaraciones y encerrada entre el comienzo y el final ..." en cuya "[e] misma declaración aparece en un bloque de esta manera y es válida sólo para ese bloque".
Sintaxis
Los bloques usan una sintaxis diferente en diferentes idiomas. Dos amplias familias son:
- la familia ALGOL en la que los bloques están delimitados por las palabras clave "
begin" y "end" o equivalente. En C , los bloques están delimitados por llaves - "{" y "}". ALGOL 68 utiliza paréntesis. - Los paréntesis: "
(" y ")", se utilizan en el lenguaje por lotes de MS-DOS. - sangría , como en Python
-
Expresiones-s con una palabra clave sintáctica como
progolet(como en la familia Lisp ) - En 1968 (con ALGOL 68 ), luego en el lenguaje de comandos guardado de 1974 de Edsger W. Dijkstra , el bloque de código condicional e iterativo se termina alternativamente con la palabra reservada del bloque invertida : por ejemplo , y
if ~ then ~ elif ~ else ~ ficase ~ in ~ out ~ esacfor ~ while ~ do ~ od
Limitaciones
Algunos lenguajes que admiten bloques con declaraciones no admiten completamente todas las declaraciones; por ejemplo, muchos lenguajes derivados de C no permiten una definición de función dentro de un bloque ( funciones anidadas ). Y a diferencia de su antepasado Algol, Pascal no admite el uso de bloques con sus propias declaraciones dentro del comienzo y el final de un bloque existente, solo declaraciones compuestas que permiten agrupar secuencias de declaraciones en if , while , repeat y otras declaraciones de control.
Semántica básica
El significado semántico de un bloque es doble. En primer lugar, proporciona al programador una forma de crear estructuras arbitrariamente grandes y complejas que pueden tratarse como unidades. En segundo lugar, permite al programador limitar el alcance de las variables y, a veces, otros objetos que se han declarado.
En los primeros lenguajes como Fortran IV y BASIC , no había bloques de instrucciones ni estructuras de control. Los condicionales se implementaron utilizando sentencias goto condicionales :
C LANGUAGE: ANSI STANDARD FORTRAN 66
C INITIALIZE VALUES TO BE CALCULATED
PAYSTX = .FALSE.
PAYSST = .FALSE.
TAX = 0.0
SUPTAX = 0.0
C SKIP TAX DEDUCTION IF EMPLOYEE EARNS LESS THAN TAX THRESHOLD
IF (WAGES .LE. TAXTHR) GOTO 100
PAYSTX = .TRUE.
TAX = (WAGES - TAXTHR) * BASCRT
C SKIP SUPERTAX DEDUCTION IF EMPLOYEE EARNS LESS THAN SUPERTAX THRESHOLD
IF (WAGES .LE. SUPTHR) GOTO 100
PAYSST = .TRUE.
SUPTAX = (WAGES - SUPTHR) * SUPRAT
100 TAXED = WAGES - TAX - SUPTAX
La estructura lógica del programa no se refleja en el lenguaje y analizar cuándo se ejecuta una determinada instrucción puede resultar difícil.
Los bloques permiten al programador tratar un grupo de sentencias como una unidad, y los valores por defecto que debían aparecer en la inicialización en este estilo de programación pueden, con una estructura de bloques, situarse más cerca de la decisión:
{ Language: Jensen and Wirth Pascal }
if wages > tax_threshold then
begin
paystax := true;
tax := (wages - tax_threshold) * tax_rate
{ The block structure makes it easier to see how the code could
be refactored for clarity, and also makes it easier to do,
because the structure of the inner conditional can easily be moved
out of the outer conditional altogether and the effects of doing
so are easily predicted. }
if wages > supertax_threshold then
begin
pays_supertax := true;
supertax := (wages - supertax_threshold) * supertax_rate
end
else begin
pays_supertax := false;
supertax := 0
end
end
else begin
paystax := false; pays_supertax := false;
tax := 0; supertax := 0
end;
taxed := wages - tax - supertax;
El uso de bloques en el fragmento anterior de Pascal aclara la intención del programador y permite combinar los bloques resultantes en una jerarquía anidada de declaraciones condicionales . La estructura del código refleja más de cerca el pensamiento del programador, lo que facilita su comprensión y modificación.
El código fuente anterior se puede aclarar aún más si se elimina la instrucción if interna de la externa, colocando los dos bloques uno tras otro para que se ejecuten consecutivamente. Semánticamente, hay poca diferencia en este caso, y el uso de la estructura de bloques, respaldada por sangrías para mejorar la legibilidad, facilita al programador la refactorización del código.
En los lenguajes primitivos, las variables tenían un alcance amplio. Por ejemplo, una variable entera llamada IEMPNO podría usarse en una parte de una subrutina de Fortran para indicar el número de seguro social de un empleado (ssn), pero durante el trabajo de mantenimiento en la misma subrutina, un programador podría usar accidentalmente la misma variable, IEMPNO, para un propósito diferente, y esto podría resultar en un error difícil de rastrear. La estructura de bloques hace que sea más fácil para los programadores controlar el alcance a un nivel mínimo.
;; Language: R5RS Standard Scheme
(let ((empno (ssn-of employee-name)))
(while (is-manager empno)
(let ((employees (length (underlings-of empno))))
(printf "~a has ~a employees working under him:~%" employee-name employees)
(for-each
(lambda(empno)
;; Within this lambda expression the variable empno refers to the ssn
;; of an underling. The variable empno in the outer expression,
;; referring to the manager's ssn, is shadowed.
(printf "Name: ~a, role: ~a~%"
(name-of empno)
(role-of empno)))
(underlings-of empno)))))
En el fragmento de esquema anterior , empno se usa para identificar tanto al gerente como a sus subordinados, cada uno por su respectivo ssn, pero debido a que el subordinado ssn se declara dentro de un bloque interno, no interactúa con la variable del mismo nombre que contiene el ssn del gerente. En la práctica, las consideraciones de claridad probablemente llevarían al programador a elegir distintos nombres de variables, pero él o ella tiene la opción y es más difícil introducir un error sin darse cuenta.
Izar
En algunos lenguajes, una variable se puede declarar en el ámbito de la función incluso dentro de bloques cerrados. Por ejemplo, en Javascript, las variables declaradas con vartienen alcance de función.