Statements and Code Blocks

In a park full of dinosaurs, every step must be carefully planned and executed in the right order. The same is true in JavaScript - code executes as a sequence of statements that must be properly structured for the program to work correctly and safely.

Statements in JavaScript

A statement in JavaScript is a command that performs a specific task. It's like a single order given to a Jurassic Park employee - for example, "feed the T-Rex" or "check the fence."

In JavaScript, each statement usually ends with a semicolon (though, as we'll see in the next lesson, this is sometimes optional):

1let dinosaurCount = 5;       // Variable declaration
2console.log("Warning!");     // Function call
3dinosaurCount++;             // Value increment

Statements are executed in the order they were written - from top to bottom. It's like a safety procedure in Jurassic Park, where steps must be performed in a strictly defined order:

1// T-Rex enclosure closing procedure
2verifyDinosaurLocation();    // 1. Verify dinosaur location
3activateGates();             // 2. Activate gates
4closeFencedArea();           // 3. Close the fenced area
5verifyEnclosureSecurity();   // 4. Verify enclosure security

Code Blocks in JavaScript

A code block is a group of statements enclosed in curly braces

{ }

. It works like a fenced zone in Jurassic Park - it designates a specific area that has its own rules and restrictions.

1// Code block controlling the dinosaur health review procedure
2{
3    let healthStatus = checkDinosaurVitals();
4    updateMedicalRecords(healthStatus);
5
6    if (healthStatus === "Critical") {
7        alertVeterinaryTeam();
8    }
9}

We use code blocks mainly in four situations:

1. Functions

Functions are key "procedures" in our park that can be executed multiple times:

1function feedCarnivore(dinosaurType, foodAmount) {
2    // This code block defines the carnivore feeding procedure
3    console.log(`Preparing meal for ${dinosaurType}`);
4    prepareMeat(foodAmount);
5    openFeedingHatch();
6    closeFeedingHatch();
7    console.log("Feeding completed");
8}

2. Conditional Statements

Just as park personnel decisions depend on various situations, in JavaScript we use code blocks with conditional statements:

1if (rainLevel > 50) {
2    // This block executes only during heavy rainfall
3    evacuateOpenAreas();
4    secureOutdoorEquipment();
5    activateEmergencyShelters();
6}

3. Loops

When the park needs to perform the same procedure for many enclosures or dinosaurs, loops are used:

1for (let i = 0; i < parkSectors.length; i++) {
2    // This block executes for each park sector
3    checkSecuritySystems(parkSectors[i]);
4    updateSecurityLogs(parkSectors[i]);
5}

4. Lexical Blocks

Sometimes we use code blocks solely to limit the scope of variables - similar to restricted access zones in the park:

1{
2    // Variables declared here are only accessible inside this block
3    let securityCode = "TRex2023";
4    activateSecurityProtocol(securityCode);
5}
6// The securityCode variable is no longer accessible here

Variable Scope

Code blocks have crucial importance for the scope of variables declared with

let

and

const

. These variables are only visible within the block in which they were declared.

It's like employees having access only to specific zones in Jurassic Park:

1{
2    // Genetic laboratory - authorized personnel only
3    let dinoGenomeSequence = "ACGTACGT...";
4
5    // The variable is only accessible here
6    modifyDinoGenome(dinoGenomeSequence);
7}
8
9// Error! This variable is not accessible outside the laboratory
10// console.log(dinoGenomeSequence);

For a better illustration, let's compare variable scopes to security zones in the park:

1// Public area (global scope)
2let parkName = "Jurassic Park";
3
4function checkParkStatus() {
5    // Employee area (function scope)
6    let isOpen = true;
7    let visitorCount = 368;
8
9    if (visitorCount > 350) {
10        // Crowd control zone (block scope)
11        let alertLevel = "Yellow";
12        console.log(`Alert level: ${alertLevel}`);
13    }
14
15    // alertLevel is not accessible here - error!
16    // console.log(alertLevel);
17}
18
19// Neither isOpen nor visitorCount are accessible here - error!
20// console.log(isOpen);

Nesting Blocks

Code blocks can also be nested (blocks within blocks), similar to how in Jurassic Park we have zones within other zones:

1// Employee zone
2{
3    let employeeAccessLevel = 2;
4
5    // Genetics zone - higher access level
6    if (employeeAccessLevel >= 3) {
7        let geneticLabAccess = true;
8
9        // High security - strict control
10        if (geneticLabAccess) {
11            let embryoStorageCode = "LS-445-23A";
12            console.log(`Access code: ${embryoStorageCode}`);
13        }
14    }
15}

Hoisting and Declarations

In JavaScript, there is a mechanism called "hoisting" - variable and function declarations are "lifted" to the top of their scope. However, values assigned to variables are not lifted.

It's like preparing all safety procedures before opening the park:

1// This function is available here thanks to hoisting
2securityCheck();
3
4// Function declaration
5function securityCheck() {
6    console.log("Security systems checked");
7}
8
9// Variables declared with var are "hoisted"
10console.log(parkStatus); // undefined, but not an error
11var parkStatus = "Open";
12
13// let and const are NOT fully hoisted
14// console.log(dinosaurCount); // Error: Cannot access 'dinosaurCount' before initialization
15let dinosaurCount = 20;

Expressions vs Statements

In JavaScript, it's important to distinguish between statements and expressions:

• Expression is code that returns a value, like examining a DNA sample that returns a result
• Statement is a command that performs an action, like a dinosaur feeding procedure

1// Expressions - return a value
25 + 3                        // Expression that returns 8
3dinosaurWeight * 0.5         // Expression that returns half the weight
4isDangerousSpecies("T-Rex")  // Expression that returns true
5
6// Statements - perform actions
7let visitorsToday = 500;     // Declaration statement
8if (visitorsToday > 400) {   // Conditional statement
9    activateCrowdControl();
10}

Practical Application

Understanding statements and code blocks is like learning the map of Jurassic Park - it allows you to safely navigate through code. Here is an example of complex code using statements, blocks, and various scopes:

1// Park monitoring system
2
3// Global variables
4const parkName = "Jurassic Park";
5let parkStatus = "Open";
6let globalAlertLevel = "Normal";
7
8// Main monitoring function
9function monitorParkSystems() {
10    let systemsOnline = true;
11
12    // Check fences
13    checkElectricalFences();
14
15    // Dinosaur monitoring block
16    {
17        let activeDinosaurs = getDinosaurStatus();
18
19        // Loop checking each dinosaur
20        for (let i = 0; i < activeDinosaurs.length; i++) {
21            let dinosaur = activeDinosaurs[i];
22
23            // Condition block for dangerous species
24            if (dinosaur.dangerLevel > 3) {
25                // Inner emergency procedure block
26                {
27                    let emergencyProtocol = `Protocol-${dinosaur.species}`;
28                    console.log(`Activation: ${emergencyProtocol}`);
29
30                    // This variable is only accessible here
31                    let emergencyTeam = selectTeamForSpecies(dinosaur.species);
32                    alertSecurityTeam(emergencyTeam);
33                }
34
35                // The emergencyTeam variable is not accessible here
36                updateSecurityLogs(dinosaur);
37            }
38        }
39    }
40
41    // Variables from the dinosaur monitoring block are not accessible here
42    return generateStatusReport();
43}
44
45// Helper function
46function checkElectricalFences() {
47    let sections = 12;
48    let failedSections = 0;
49
50    for (let i = 1; i <= sections; i++) {
51        let sectionStatus = getFenceStatus(i);
52
53        if (sectionStatus !== "Active") {
54            failedSections++;
55
56            // Emergency block
57            {
58                let repairTeam = "Echo";
59                dispatchRepairTeam(repairTeam, i);
60            }
61        }
62    }
63
64    if (failedSections > 0) {
65        globalAlertLevel = "Elevated";
66    }
67}

In the above example, you can see how code blocks can be used to organize code, control variable scope, and create a logical program structure. Each block works like a separate zone in the park, with its own rules and restrictions.

Summary

Statements and code blocks in JavaScript are like safety procedures and zones in Jurassic Park - they maintain order, organization, and safety. Well-organized code that properly uses statements and blocks is easier to understand, maintain, and develop.

Key concepts to remember:

1. Statements are individual commands ending with a semicolon
2. Code blocks are groups of statements enclosed in curly braces

   { }

3. Variable scope is limited by the block in which they were declared (for

   let

   and

   const

   )
4. Hoisting is the mechanism of "lifting" variable and function declarations
5. Expressions return a value, while statements perform actions

In the next lesson, we will take a closer look at semicolons in JavaScript and their optionality, which is like learning the nuances of park safety protocols - sometimes they are absolutely necessary, and other times they can be omitted.