Blok (programowanie) - Block (programming)

W programowaniu komputerowym , o blok lub kod blok lub blok kodu jest leksykalny struktura kodu źródłowego , które są zgrupowane razem. Bloki składają się z jednej lub więcej deklaracji i instrukcji . Język programowania, który umożliwia tworzenie bloków, w tym bloków zagnieżdżonych w innych blokach, nazywany jest językiem programowania o strukturze blokowej . Bloki są podstawą programowania strukturalnego , w którym struktury sterujące są tworzone z bloków.

Bloki pełnią dwie funkcje: grupują instrukcje tak, aby mogły być traktowane jako jedna instrukcja; i zdefiniować zakresy dla nazw, aby odróżnić je od tej samej nazwy używanej gdzie indziej. W języku programowania o strukturze blokowej obiekty nazwane w blokach zewnętrznych są widoczne wewnątrz bloków wewnętrznych, chyba że są zamaskowane przez obiekt zadeklarowany o tej samej nazwie.

Historia

Idee struktury blokowej zostały opracowane w latach pięćdziesiątych podczas opracowywania pierwszych autokodów i zostały sformalizowane w raportach Algol 58 i Algol 60 . Algol 58 wprowadził pojęcie „wyrażenia złożonego”, które dotyczyło wyłącznie przepływu sterowania . Kolejny poprawiony raport, który opisywał składnię i semantykę Algolu 60, wprowadził pojęcie bloku i zakresu bloku , z blokiem składającym się z „Sekwencji deklaracji, po której następuje sekwencja instrukcji i zawartej między początkiem i końcem...” w które „każda deklaracja pojawia się w bloku w ten sposób i jest ważna tylko dla tego bloku”.

Składnia

Bloki używają różnej składni w różnych językach. Dwie szerokie rodziny to:

  • ALGOL rodzina, w której bloki są ograniczone przez słowa kluczowe „ begin” oraz „ end” lub równoważne. W języku C bloki są oddzielone nawiasami klamrowymi - " {" i " }". ALGOL 68 używa nawiasów.
  • Nawiasy - " (" i " )" są używane w języku wsadowym MS-DOS
  • wcięcie , jak w Pythonie
  • s-wyrażenia ze słowem kluczowym składni, takim jak proglub let(jak w rodzinie Lisp )
  • W 1968 roku (z Algol 68 ), a następnie w Edsger Dijkstra „s 1974 Strzeżonego Command Language warunkowe i iteracyjne blok kodu są alternatywnie zakończone bloku zarezerwowane słowa odwrócone : na przykład , iif ~ then ~ elif ~ else ~ ficase ~ in ~ out ~ esacfor ~ while ~ do ~ od

Ograniczenia

Niektóre języki obsługujące bloki z deklaracjami nie obsługują w pełni wszystkich deklaracji; na przykład wiele języków wywodzących się z C nie zezwala na definicję funkcji w bloku ( funkcje zagnieżdżone ). I w przeciwieństwie do swojego przodka, Algola, Pascal nie obsługuje używania bloków z własnymi deklaracjami na początku i na końcu istniejącego bloku, a jedynie instrukcje złożone umożliwiające grupowanie sekwencji instrukcji w instrukcje if , while , repeat i inne instrukcje sterujące.

Podstawowa semantyka

Semantyczne znaczenie bloku jest dwojakie. Po pierwsze, daje programiście możliwość tworzenia dowolnie dużych i złożonych struktur, które można traktować jako jednostki. Po drugie, umożliwia programiście ograniczenie zakresu zmiennych, a czasem innych obiektów, które zostały zadeklarowane.

We wczesnych językach, takich jak Fortran IV i BASIC , nie było bloków instrukcji ani struktur kontrolnych. Warunki zostały zaimplementowane za pomocą warunkowych instrukcji goto :

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

Logiczna struktura programu nie jest odzwierciedlona w języku, a analiza, kiedy dana instrukcja jest wykonywana, może być trudna.

Bloki pozwalają programiście traktować grupę instrukcji jako jednostkę, a wartości domyślne, które musiały pojawić się podczas inicjalizacji w tym stylu programowania, można, za pomocą struktury blokowej, umieścić bliżej decyzji:

    { 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;

Użycie bloków w powyższym fragmencie Pascala wyjaśnia intencje programisty i umożliwia łączenie wynikowych bloków w zagnieżdżoną hierarchię instrukcji warunkowych . Struktura kodu lepiej odzwierciedla myślenie programisty, co ułatwia jego zrozumienie i modyfikację.

Powyższy kod źródłowy można uczynić jeszcze jaśniejszym, usuwając wewnętrzną instrukcję if z zewnętrznej, umieszczając dwa bloki jeden po drugim, aby były wykonywane kolejno. Semantycznie różnica w tym przypadku jest niewielka, a użycie struktury blokowej, wspieranej przez wcięcia dla czytelności, ułatwia programiście refaktoryzację kodu.

W prymitywnych językach zmienne miały szeroki zakres. Na przykład zmienna całkowita o nazwie IEMPNO może być używana w jednej części podprogramu Fortran do oznaczenia numeru ubezpieczenia społecznego pracownika (ssn), ale podczas prac konserwacyjnych nad tym samym podprogramem programista może przypadkowo użyć tej samej zmiennej, IEMPNO, do inny cel, a to może skutkować błędem, który był trudny do wyśledzenia. Struktura blokowa ułatwia programistom kontrolowanie zakresu do minimalnego poziomu.

;; 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)))))

W powyższym fragmencie schematu , empno służy do identyfikowania zarówno menedżera, jak i jego podwładnych przez ich odpowiedni ssn, ale ponieważ ssn podwładnego jest zadeklarowany w bloku wewnętrznym, nie oddziałuje ze zmienną o tej samej nazwie, która zawiera ssn kierownika W praktyce względy przejrzystości prawdopodobnie skłoniłyby programistę do wybrania odrębnych nazw zmiennych, ale ma on wybór i trudniej jest nieumyślnie wprowadzić błąd.

Podnoszenie

W niektórych językach zmienną można zadeklarować w zakresie funkcji nawet w zamkniętych blokach. Na przykład w JavaScript zmienne zadeklarowane za pomocą varmają zakres funkcji.

Zobacz też

Bibliografia