Script blocks for Groovy in Jenkins - Step-by-Step Execution

Process Flow - Script blocks for Groovy

Start Script Block

↓

Define Variables & Logic

↓

Execute Statements in Order

↓

Return Last Expression Result

↓

End Script Block

A Groovy script block runs code inside braces { } sequentially, defining variables and executing statements, returning the last expression's value.

Execution Sample

Jenkins

def result = {
  def x = 5
  def y = 10
  x + y
}
println(result())

Defines a script block that adds two numbers and prints the result.

Process Table

Step	Action	Evaluation	Result
1	Enter script block	Start block execution	No output yet
2	Define x	x = 5	x = 5
3	Define y	y = 10	y = 10
4	Evaluate last expression	x + y	15
5	Return result from block	Block returns 15	result = closure returning 15
6	Call result()	Execute block	Prints 15

💡 Script block ends after last expression; calling result() runs the block and outputs 15

Status Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
x	undefined	5	5	5	5
y	undefined	undefined	10	10	10
result	undefined	undefined	undefined	closure	closure returning 15

Key Moments - 2 Insights

Why does the script block return the value of the last expression?

In Groovy, a script block returns the value of its last evaluated expression automatically, as shown in step 4 of the execution_table where 'x + y' evaluates to 15.

What happens when we call result() after defining the script block?

Calling result() executes the script block code inside the closure, producing the output 15 as shown in step 6 of the execution_table.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'y' after step 3?

A undefined

B 5

C 10

D 15

💡 Hint

Check the 'variable_tracker' table column 'After Step 3' for variable 'y'

At which step does the script block return its final value?

A Step 4

B Step 5

C Step 2

D Step 6

💡 Hint

Look at the 'execution_table' row where the block returns the value

If we change 'x' to 7, what will be the output when calling result()?

A 17

B 15

C 10

D 7

💡 Hint

Sum of x and y is returned; see 'variable_tracker' and 'execution_table' for how values combine

Concept Snapshot

Groovy script blocks use braces { } to group code.
They run statements in order and return the last expression's value.
Variables inside are local to the block.
Call the block like a function to execute it.
Useful for grouping logic in Jenkins pipelines.

Full Transcript

A Groovy script block is a group of code inside braces { } that runs sequentially. Inside, you can define variables and write expressions. The block automatically returns the value of the last expression it evaluates. For example, defining variables x and y inside the block and adding them returns their sum. When you assign this block to a variable like 'result', you get a closure. Calling result() runs the block and outputs the final value. This behavior is common in Jenkins pipelines to group and execute code chunks cleanly.

Practice

1. What is the main purpose of using script blocks in Jenkins pipelines?

easy

A. To define environment variables

B. To specify the agent where the pipeline runs

C. To run Groovy code for custom logic inside the pipeline

D. To declare pipeline stages

Solution

1. Step 1: Understand Jenkins pipeline structure

   Jenkins pipelines use declarative syntax but allow Groovy code inside script blocks for flexibility.

2. Step 2: Identify the role of script blocks

   script blocks let you write Groovy code for loops, conditions, and other logic not directly supported in declarative syntax.

3. Final Answer:

   To run Groovy code for custom logic inside the pipeline -> Option C

4. Quick Check:

   Script blocks = Groovy code inside pipeline [OK]

Hint: Script blocks run Groovy code inside steps [OK]

Common Mistakes:

• Confusing script blocks with environment or agent declarations
• Thinking script blocks define stages
• Assuming script blocks are optional for all logic

2. Which of the following is the correct way to start a script block inside a declarative Jenkins pipeline?

easy

A. script { echo 'Hello' }

B. script: { echo 'Hello' }

C. script() { echo 'Hello' }

D. script => { echo 'Hello' }

Solution

1. Step 1: Recall correct syntax for script blocks

   In declarative pipelines, script is a block keyword followed by curly braces containing Groovy code.

2. Step 2: Compare options

   Only script { ... } is valid Groovy block syntax. Others use invalid punctuation or keywords.

3. Final Answer:

   script { echo 'Hello' } -> Option A

4. Quick Check:

   script block syntax = script { ... } [OK]

Hint: Use script { } with braces, no colons or arrows [OK]

Common Mistakes:

• Using colons or arrows instead of braces
• Adding parentheses after script keyword
• Misplacing quotes or braces

3. What will be the output of this Jenkins pipeline snippet?

pipeline {
  agent any
  stages {
    stage('Example') {
      steps {
        script {
          def sum = 0
          for (i in 1..3) {
            sum += i
          }
          echo "Sum is ${sum}"
        }
      }
    }
  }
}

medium

A. Sum is 6

B. Sum is 3

C. Sum is 0

D. Syntax error

Solution

1. Step 1: Analyze the for loop inside script block

   The loop runs from 1 to 3 inclusive, adding each number to sum: 1 + 2 + 3 = 6.

2. Step 2: Understand echo output

   The echo prints the string with sum value interpolated, so output is "Sum is 6".

3. Final Answer:

   Sum is 6 -> Option A

4. Quick Check:

   1+2+3=6 output = Sum is 6 [OK]

Hint: Sum 1 to 3 = 6; echo prints it [OK]

Common Mistakes:

• Thinking loop ends at 2
• Confusing sum initialization
• Assuming syntax error due to script block

4. Identify the error in this Jenkins pipeline snippet using a script block:

pipeline {
  agent any
  stages {
    stage('Test') {
      steps {
        script {
          for i in 1..3 {
            echo "Number: ${i}"
          }
        }
      }
    }
  }
}

medium

A. Script block must be outside steps

B. Incorrect use of echo inside script block

C. Agent declaration is invalid

D. Missing parentheses around for loop variable and range

Solution

1. Step 1: Check for loop syntax in Groovy

   Groovy requires parentheses around the for loop variable and range: for (i in 1..3).

2. Step 2: Identify the error in given code

   The code uses for i in 1..3 without parentheses, causing syntax error.

3. Final Answer:

   Missing parentheses around for loop variable and range -> Option D

4. Quick Check:

   Groovy for loop needs ( ) [OK]

Hint: Always use parentheses in Groovy for loops [OK]

Common Mistakes:

• Omitting parentheses in for loops
• Misplacing script block outside steps
• Confusing echo usage inside script

5. You want to use a script block in Jenkins to create a map of numbers to their squares for numbers 1 to 4, then print each pair. Which code snippet correctly does this inside a script block?

hard

A. def squares = []
for (i in 1..4) {
squares.add(i * i)
}
squares.each { echo "${it} squared" }

B. def squares = [:]
for (i in 1..4) {
squares[i] = i * i
}
squares.each { k, v -> echo "${k} squared is ${v}" }

C. def squares = [:]
for i in 1..4 {
squares[i] = i * i
}
squares.each { k, v -> echo "${k} squared is ${v}" }

D. def squares = [:]
for (i in 1..4) {
squares[i] = i ^ 2
}
squares.each { k, v -> echo "${k} squared is ${v}" }

Solution

1. Step 1: Check map creation and loop syntax

   def squares = [:] for (i in 1..4) { squares[i] = i * i } squares.each { k, v -> echo "${k} squared is ${v}" } correctly creates an empty map with [:] and uses parentheses in the for loop.

2. Step 2: Verify square calculation and iteration

   def squares = [:] for (i in 1..4) { squares[i] = i * i } squares.each { k, v -> echo "${k} squared is ${v}" } uses i * i for squares and iterates map with each { k, v -> ... } to echo key-value pairs.

3. Final Answer:

   def squares = [:] for (i in 1..4) { squares[i] = i * i } squares.each { k, v -> echo "${k} squared is ${v}" } -> Option B

4. Quick Check:

   Map with for (i in 1..4) and i*i is correct [OK]

Hint: Use [:] for map, for (i in range), i*i for squares [OK]

Common Mistakes:

• Using list [] instead of map [:]
• Omitting parentheses in for loop
• Using ^ for power instead of *
• Incorrect map iteration syntax