Linux Command Line Mastery · Lesson

Loops: `for`, `while`, `until`

Automate repetitive tasks by mastering different types of loops in shell scripting.

Loops: `for`, `while`, `until` is a free Linux Command Line Mastery lesson on CoddyKit — lesson 3 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Linux Command Line Mastery learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Why Use Loops?

Imagine you need to perform the same action many times, like saying 'Hello' to everyone in a list, or counting from 1 to 100. Doing this manually would be tedious and error-prone.

This is where loops come in! Loops allow your script to repeat a set of commands multiple times, saving you effort and making your scripts more efficient.

Looping Through Items with `for`

The for loop is perfect when you know exactly what items you want to iterate over. It goes through a list, processing each item one by one.

Its basic syntax looks like this:

for item in list; do
# commands to run for each item
done

The item variable will hold each value from the list in turn.

`for` Loop in Action

Let's see the for loop iterate through a list of names. Each name is assigned to the name variable, and then printed.

Try running this example:

#!/bin/bash

echo "--- Greeting Friends ---"
for name in Alice Bob Charlie;
do
  echo "Hello, $name!"
done
echo "--- All greeted! ---"

`for` Loop for Number Ranges

What if you need to loop a specific number of times, like counting from 1 to 5? You can generate sequences for the for loop:

Brace Expansion: {1..5} creates "1 2 3 4 5".
seq command: $(seq 1 5) also creates "1 2 3 4 5".

Both are handy for numerical iterations.

Counting with `for` Loop

Here's how you can use brace expansion to count up to a specific number. The loop variable i takes on each number in the sequence.

Try running this example:

#!/bin/bash

echo "Counting up!"
for i in {1..3};
do
  echo "Count: $i"
done
echo "Done counting."

Repeating with `while`

The while loop is used when you want to repeat commands as long as a certain condition remains true. It continuously checks the condition before each iteration.

Its basic structure is:

while condition; do
# commands to run
done

The loop stops as soon as the condition becomes false.

`while` Loop Counter

Let's use a while loop to count. We initialize a variable count, and the loop continues as long as count is less than 3.

Remember to update the variable inside the loop, or it might run forever (an 'infinite loop')!

#!/bin/bash

count=0
echo "Starting while loop..."
while [ $count -lt 3 ]; do
  echo "Current count: $count"
  count=$((count + 1))
done
echo "While loop finished."

Repeating `until` True

The until loop is similar to while, but with an inverse condition. It executes commands until a specified condition becomes true.

Its syntax is:

until condition; do
# commands to run
done

The loop continues as long as the condition is false.

`until` Loop in Action

Here's an until loop waiting for a variable num to reach 3. It will keep running as long as num is not greater than or equal to 3.

Try running this example:

#!/bin/bash

num=0
echo "Starting until loop..."
until [ $num -ge 3 ]; do
  echo "Current number: $num"
  num=$((num + 1))
done
echo "Until loop finished."

When to Use Which Loop?

Choosing the right loop makes your scripts clearer and more efficient:

for loop: Best for iterating over a known list of items (files, names, numbers in a range).
while loop: Ideal when you need to repeat commands as long as a condition holds true (e.g., reading lines from a file, waiting for user input, counting).
until loop: Useful when you want to repeat commands until a specific condition becomes true (e.g., waiting for a process to finish, retrying an operation).

Loop Challenge

Let's test your understanding of shell loops.

Loops: A Quick Recap

Well done! You've learned the fundamental looping constructs in shell scripting:

The for loop iterates over a fixed list of items or a range.
The while loop repeats commands as long as a condition is true.
The until loop repeats commands until a condition becomes true.

These loops are essential for automating repetitive tasks and making your scripts dynamic and powerful. Keep practicing!

Frequently asked questions

Is the “Loops: `for`, `while`, `until`” lesson free?

Yes — the full text of “Loops: `for`, `while`, `until`” is free to read here on the web, and the Linux Command Line Mastery course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Linux Command Line Mastery course, upgrade to CoddyKit PRO.

What will I learn in “Loops: `for`, `while`, `until`”?

Automate repetitive tasks by mastering different types of loops in shell scripting. You practise Linux Command Line Mastery with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Linux Command Line Mastery?

No prior experience is required. Linux Command Line Mastery on CoddyKit is structured for beginners through advanced learners; this is — lesson 3 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Loops: `for`, `while`, `until`” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Linux Command Line Mastery lesson?

Yes. Every Linux Command Line Mastery lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

Variables, Input, and Output
Conditional Statements: `if`, `else`, `case`
Loops: `for`, `while`, `until`
Functions and Arguments in Shell Scripts

← Back to Linux Command Line Mastery