Shulou(Shulou.com)06/03 Report--

This article introduces the knowledge of "how to use curly braces in programming". In the operation of actual cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

First of all, take non-block language as an example.

All programmers familiar with C-style programming syntax are familiar with programming blocks, and all major programming structures written in C, C + +, Java, JavaScript, and other languages are block structured. In other words, the body of these constructs is placed in blocks separated by open and closed curly braces.

One might say that this is not entirely true, because if statements and loops (there are only two programming constructs mentioned here) can be constructed without blocks if their body has only one statement. Over the past few years, however, programming style experts have suggested putting all constructs in one block (see Douglas Cockroft's "_ JavaScript: The Good Parts" argument for putting all if and loop bodies in a block).

However, the first high-level programming languages did not have blocks.

I will demonstrate this in the FORTRAN language around the late 1950s.

Donald Knuth compares the features of several early programming languages in his excellent commentary on early high-level programming languages, "early Development of programming languages," which is reproduced in his book anthology of computer languages. His approach is to demonstrate how a computer program can be implemented in different languages. This program implements an algorithm called TPK algorithm, which in modern JavaScript looks like this:

Function f (t) {return Math.sqrt (Math.abs (t) + 5 * Math.pow (t, 3));} let arr = []; let y; for (let I = 0; I

< 11; i++) { putstr("Enter a number: "); arr[i] = parseFloat(readline()); } for (let i = 10; i >

= 0; is too large -) {y = f (arr [I]) if (y > 400) {print (y, "is too large.");} else {print (iMagol y)}}

Don't worry about what the program does. Importantly, this program implements all the features that Knuth considers important for testing in modern programming languages.

As I mentioned, Knuth compares several programming languages with this algorithm. The last language he saw is now generally considered to be the first truly high-level programming language. Here is what the TPK program written by Knuth looks like in Fortran:

C THE TPK ALGORITHM, FORTRAN STYLE FUNF (T) = SQRTF (ABSF (T)) + 5.0*T**3 DIMENSION A (11) 1 FORMAT (6F12.4) READ 1, A DO 10 J = 1, 11 I = 11-J Y = FUNF (A (II) 1) IF (400.0 PRINT Y) 4,8,8 4 PRINT 5, I 5 FORMAT (I 10,10H TOO LARGE) GO TO 10 8 PRINT 9, I, Y 9 FORMAT (I10 F12.7) 10 CONTINUE STOP 52525

I won't go into the details of the Fortran syntax, but you can clearly see that the language does not contain blocks. The function is defined on a line, not as a block of code, and the DO loop uses a line label to control the loop. At that time, high-level languages did not have the concept of grouping compound statements into blocks, and these languages still relied on goto to control program flow.

This code was written by Knuth using the 1957 version of Fortran. Between 1957 and 1960, a new language, ALGOL, was developed, which made up for many shortcomings of languages such as Fortran and other high-level languages at that time.

Blocks in Algol

The Algol programming language was first described in 1958, although the most popular version of the language was Algol 60. One of the functions of Algol is the ability to group statements into compound statements (called blocks), and each Algol program is treated as a block because a program usually contains one or more statements (and therefore compound statements). Algol developers recognize that many programming scenarios, such as conditions and loops, need to consider statements as a unit.

Algol marks the beginning and end of the block with the keywords begin and end. One block can be nested within another block, the outer block is considered to be the dominant block, and the inner block is considered to be the subordinate block. For example, here is an Algol program that can nest blocks:

Begin real a; a: = 1; begin real a; a: = 2; print (a) end; print (a) end

Print the numbers 2 and 1 in turn.

This is an example of how blocks are used in Algol's if statements:

If x >-1 then begin if x ≠ 0 then x: = 1 Universe x end

This is an example of a for loop block in Algol:

Begin real a0, A1, a2, a3, z, p; integer n, I; read (a0, A1, a2, a3); read (n) for I: = 1 step 1 until n do begin read (z); p: = (a3 × z + a2) × z + A1) × z + a0 print (p) end i end

Now let's take a look at the TPK program in Algol and see how the block structure helps the program compared to the Fortran version:

TPK begin integer i, real y; real a [0:10]; real procedure f (t); real t; value t; f: = sqrt (abs (t)) + 5 × t ↑ 3; for I: = 0 step 1 until 10 do read (a [I]); for I: = 10 step-1 until 0 do begin y: = f (a [I]) If y > 400then write (I, 'TOO LARGE') else write (I, y); end end TPK

As you can see, the block structure of the Algol version makes it more like the code you and I are used to reading today.

Go to BCPL

The next change in the syntax of the block structure language is the BCPL language developed by Martin Richards (Martin Richards) of Cambridge University in 1967. During the initial development of Algol from 1960 to 1967, compilers and system developers were looking for ways to develop system applications, such as operating systems, in languages other than machine and assembly languages. I emphasize BCPL because C is developed through an intermediate language called B developed by Ken Thompson as a refinement and improvement of BCPL.

Richards develops BCPL as a system development language that is as efficient as assembly language, but with a higher level of syntax, making coding simpler and more efficient. This means that many features of high-level languages such as Algol need to be included in languages such as BCPL in a more efficient way.

One way to achieve this efficiency is to simplify the assignment of a code block from words (begin and end) to symbols. For compound statements and code blocks, Richards chooses the symbol $(for the beginning and) $for the end, which is called section parentheses.

In BCPL, if $(and) $is used with a structure, such as an if statement or loop, then they are qualifying a compound statement, and if $(including some declarations), they are demarcating a block.

For example, here is how to write an if statement with a compound statement in BCPL:

IF A

< B $( LET T = A A := B; B := T $) 这是BCPL块的示例： GET "LIBHDR" LET START() BE $( LET A, B, C, SUM = 1, 2, 3, 0 SUM := A + B + C WRITES("Sum is ") WRITEN(SUM) $) 在这里，开始部分方括号是开始一个块，因为声明紧跟着方括号。 (和) 在C中成为 { 和 } 大约在1968年或1969年，贝尔实验室的肯-汤普森和丹尼斯-里奇开始尝试使用系统编程语言开发操作系统。汤普森其实一开始就尝试使用Fortran进行探索，但当他意识到这不可能时，很快就放弃了。他决定要对BCPL进行修改，使其成为一种更符合自己喜好的系统编程语言，于是开发了B。 B虽然更接近汤普森和里奇想要的系统开发语言，但仍然不能完全满足他们的需求，所以里奇开始为新的B开发另一种语言NB。NB的生命力并不长，最终被一种全新的语言所取代，他们自然而然地称之为C。如果你对C语言是如何从BCPL、B和NB发展而来的感兴趣，我鼓励你阅读丹尼斯-里奇的《C语言的历史》。

One of the many things that Thompson fixed in B and continued to NB and then fixed in C was the abbreviation operator, which was necessary to adapt the extended language to the computer's memory limitations at the time. For example, Thompson created the compound assignment operator (+ = as an example) and the increment (+) and decrement (-) operators as a way to improve language efficiency. This is done to improve efficiency, causing other operators of BCPL to be simplified-- for example, $(and $) are replaced by {and}.

That's all for "how to use curly braces in programming". Thank you for reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.