imported>QuantumNinus: /* See also */

2025-10-29T22:14:40Z

See also

New page

{{Short description |Demarcated group of source code statements that run in sequence}}
{{distinguish|Block programming}}
{{redirect|Code block|the IDE|Code::Blocks|block-based programming|Visual programming language}}
{{refimprove|date=May 2010}}
In [[computer programming]], a '''block''' of [[source code]] is a grouping of [[Statement (computer science)|statements]] that [[Execution (computing)|execute]] in sequential order; top to bottom. The block structure is fundamental to [[structured programming]], where [[control structure]]s are formed with blocks. [[Syntax (programming languages)|Syntactically]], a block acts much like a single statement in that a control structure generally operates either on a single statement or a block.

The nature of a block varies by [[programming language]], but there are typical features. A block usually provides for visibility [[scope (computer science)|scope]] such that an [[identifier]] defined in a block is not visible in outer, containing blocks, but is visible in inner, [[Nesting (computing)|nested]] blocks unless it is [[Name masking |masked]] by an identifier with the same name. A block usually provides for lifetime scope such that [[system resource |resources]] associated with an identifier are partially or fully released when [[control flow]] reaches the end of the block in which the identifier was defined.

==History==
The block concept was developed in the 1950s during the development of the first [[autocode]]s, and was formalized in the [[Algol 58]] and [[Algol 60]] reports. Algol 58 introduced the notion of the "compound statement", which was related solely to [[control flow]].<ref name="algol58_report">{{cite journal
|last1= Perlis |first1 = A. J. |author-link1=Alan Perlis
|last2= Samelson |first2= K.
| date = 1958
| title = Preliminary report: international algebraic language
| journal = Communications of the ACM
| doi = 10.1145/377924.594925
| publisher =ACM
| location = New York, NY, USA
| volume = 1
| issue = 12
| pages = 8–22
|s2cid = 28755282 | doi-access = free
}}</ref> The subsequent ''Revised Report'' which described the syntax and semantics of Algol 60 introduced the notion of a block and [[block scope]], with a block consisting of " A sequence of declarations followed by a sequence of statements and enclosed between begin and end..." in which "[e]very declaration appears in a block in this way and is valid only for that block."<ref name="algol60_report">{{cite journal |last1=Backus |first1=J. W. |author-link1=John Backus |last2=Bauer |first2=F. L. |author-link2=Friedrich L. Bauer |last3=Green |first3=J. |last4=Katz |first4=C. |last5=McCarthy |first5=J. |last6=Perlis |first6=A. J. |last7=Rutishauser |first7=H. |author-link7=Heinz Rutishauser |last8=Samelson |first8=K. |last9=Vauquois |first9=B. |author-link9=Bernard Vauquois |last10=Wegstein |first10=J. H. |last11=van Wijngaarden |first11=A. |last12=Woodger |first12=M. |date=May 1960 |editor1-last=Naur |editor1-first=Peter |title=Report on the Algorithmic Language ALGOL 60 |url=http://www.masswerk.at/algol60/report.htm |journal=Communications of the ACM |location=New York, NY, USA |publisher=ACM |volume=3 |issue=5 |pages=299–314 |doi=10.1145/367236.367262 |issn=0001-0782 |s2cid=278290 |access-date=2009-10-27 |doi-access=free |editor1-link=Peter Naur}}</ref>

==Syntax==
A block is demarcated in code as a separate unit, but the syntax varies by language. Notable examples include:

; Curly braces: [[C (programming language)|C]] and many related languages delimit a block with <code>{</code> and <code>}</code>. In fact, this is the defining quality of a [[curly brace language]].

; Indentation: [[Python (programming language)|Python]] and [[Haskell]] use [[off-side rule |indentation]] to demarcate a block instead of delimiters as most languages do.

; Parentheses: The [[batch file]] syntax uses <code>(</code> and <code>)</code>.

; begin/end: The [[ALGOL]] family generally delimits a block with the keywords <code>begin</code> and <code>end</code>; [[ALGOL 68]] uses parentheses.

; Control verb reversed: With [[ALGOL 68]], then in [[Edsger W. Dijkstra]]'s 1974 [[Guarded Command Language#Selection: if|Guarded Command Language]] the conditional and iterative code block are alternatively terminated with the block reserved word ''reversed'': e.g. <code>'''if''' ~ then ~ elif ~ else ~ '''fi'''</code>, <code>'''case''' ~ in ~ out ~ '''esac'''</code> and <code>for ~ while ~ '''do''' ~ '''od'''</code>.

; [[S-expression]]: With a syntactic keyword such as <code>prog</code> or <code>let</code> as in the [[Lisp (programming language)|Lisp]] family.

==Limitations==
Some languages which support declarations in a block do not support all declarations. For instance, many C-related languages do not permit a [[nested function |function definition within a block]]. And unlike its ancestor Algol, Pascal does not support the use of blocks with their own declarations inside the begin and end of an existing block; only compound statements enabling sequences of statements to be grouped together in {{code |if}}, {{code |while}}, {{code |repeat}} and other control statements.{{clarify| What does 'existing block' mean? what does this mean: 'only compound statements enabling sequences of statements to be grouped together ...'? |date=September 2025}}

==Examples==
In the early days of computing, many languages such as [[FORTRAN IV]] and [[BASIC]] lacked block syntax except sometimes for rudimentary loop constructs. A conditional was encoded using the [[goto]] statement. In the following FORTRAN 66 code, the logical structure is less than clear due to the lack of blocks.

<syntaxhighlight lang="fortranfixed">
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
</syntaxhighlight>

Blocks allow the programmer to treat a group of statements as a unit, and the default values which had to appear in initialization in this style of programming can, with a block structure, be placed closer to the decision. The following code in Jensen and Wirth Pascal shows that 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. Use of blocks in the fragment below clarifies the programmer's intent, and enables combining the resulting blocks into a nested hierarchy of [[Conditional (computer programming)|conditional]] statements. The structure of the code reflects the programmer's thinking more closely, making it easier to understand and modify. The code can be made even clearer by taking the inner if statement out of the outer one altogether, placing the two blocks one after the other to be executed consecutively. Semantically, there is little difference in this case, and the use of block structure, supported by indenting for readability, makes it easy for the programmer to refactor the code.

<syntaxhighlight lang="pascal">
if wages > tax_threshold then
begin
paystax := true;
tax := (wages - tax_threshold) * tax_rate
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;
</syntaxhighlight>

In primitive languages, variables had broad scope. For instance, an integer variable called IEMPNO might be used in one part of a Fortran subroutine to denote an employee social security number (SSN), but during maintenance work on the same subroutine, a programmer might accidentally use the same variable, IEMPNO, for a different purpose, and this could result in a bug that was difficult to trace. Block structure makes it easier for programmers to control scope.

In the following R5RS Standard [[Scheme (programming language)| Scheme]] fragment, empno is used to identify both the manager and their underlings each by their respective SSN, but because the underling SSN is declared within an inner block it does not interact with the variable of the same name that contains the manager's SSN. In practice, considerations of clarity would probably lead the programmer to choose distinct variable names, but they have the choice and it is more difficult to introduce a bug inadvertently. Within the 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.

<syntaxhighlight lang="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)
(printf "Name: ~a, role: ~a~%"
(name-of empno)
(role-of empno)))
(underlings-of empno)))))
</syntaxhighlight>

==Hoisting==
In some languages, a variable can be declared at function scope even within enclosed blocks. For example, in JavaScript, variables declared with <code>var</code> have function scope.

==See also==
{{Portal|Computer programming}}
* [[Basic block]]
* [[Block scope]]
* [[Closure (computer programming)]]
* [[Decomposition (computer science)]]

==References==
{{Reflist}}
{{Programming paradigms navbox}}
{{DEFAULTSORT:Statement Block}}
[[Category:Programming constructs]]

Block (programming) - Revision history

imported>QuantumNinus: /* See also */