How to Iterate Over a Range of Integers in Go

By the end of this page, you will understand how Go handles numeric iteration, why range does not work like Ruby ranges, and the idiomatic way to loop through integers using Go's for statement. You will also learn how to build your own integer range values when needed.

Go does not have a built-in integer range type like Ruby's Range, and range in Go does not mean “generate numbers from start to end.”

In Go, range is used to iterate over existing collections or stream-like values, such as:

• arrays
• slices
• maps
• strings
• channels

That means range works over data that already exists. It does not create a sequence of integers for you.

If you want to count from 1 to 10 in Go, the idiomatic solution is a regular for loop:

for i := 1; i <= 10; i++ {
    fmt.Println(i)
}

This matters because Go is intentionally simple. Instead of adding a special numeric range syntax, the language relies on one flexible looping construct: for.

So the key idea is:

• Use range to iterate over an existing collection.
• Use for with start, condition, and increment to iterate through numbers.

If you really need a reusable range-like value, you can create a slice of integers yourself or define your own helper function.

Think of Go's range like walking through items that are already placed in a row on a table.

• A slice: a row of values already exists.
• A map: a set of key-value pairs already exists.
• A string: a sequence of characters already exists.

But a numeric interval like 1..10 is not a row of stored values in Go. It is only an idea: “start here and count until there.”

For that, Go expects you to use a for loop, which is like saying:

1. Start at 1
2. Keep going while i <= 10
3. Add 1 each time

So range walks over something that exists, while for can generate a counting process.

Basic numeric loop

The standard way to iterate over integers in Go is:

for i := 1; i <= 10; i++ {
    fmt.Println(i)
}

This means:

• initialize i to 1
• continue while i <= 10
• increment i after each iteration

Starting from zero

for i := 0; i < 5; i++ {
    fmt.Println(i)
}

Output:

0
1
2
3
4

Using range with a slice instead

If you create a slice first, then you can use range:

numbers := []int{1, 2, 3, 4, 5}

for index, value :=  numbers {
    fmt.Println(index, value)
}

Consider this code:

for i := 3; i <= 5; i++ {
    fmt.Println(i)
}

Step by step:

1. i := 3

   • Go creates i and sets it to 3.

2. i <= 5

   • 3 <= 5 is true, so the loop body runs.
   • fmt.Println(i) prints 3.

3. i++

   • i becomes 4.

4. i <= 5

   • 4 <= 5 is true.
   • Print 4.

5. i++

Numeric iteration appears everywhere in Go programs.

Repeating work a fixed number of times

for i := 0; i < 3; i++ {
    fmt.Println("Retrying...")
}

Useful for retry attempts, polling, or repeated tasks.

Processing indexes in a slice

items := []string{"a", "b", "c"}
for i := 0; i < len(items); i++ {
    fmt.Println(i, items[i])
}

Helpful when you need index-based access.

Generating test data

for i := 1; i <= 100; i++ {
    fmt.Println("user", i)
}

Common in scripts, fixtures, and sample data generation.

Pagination and batching

for page := 1; page <= totalPages; page++ {
    fmt.Println("Fetching page", page)
}

Useful in APIs and background jobs.

Time-based counters or simulations

In real Go codebases, developers usually prefer the simplest tool that matches the job.

Simple counting with for

For numeric loops, a standard for loop is the default choice:

for i := 0; i < maxRetries; i++ {
    err := tryOperation()
    if err == nil {
        break
    }
}

Guarding loop boundaries carefully

Developers often use constants or variables to avoid magic numbers:

const maxWorkers = 5
for i := 0; i < maxWorkers; i++ {
    startWorker(i)
}

Index loops when values must be updated

scores := []int{10, 20, 30}
for i := 0; i < len(scores); i++ {
    scores[i] += 5
}

This is common when you need to modify elements in place.

range when iterating existing data

Mistake 1: Expecting range to generate numbers

Broken idea:

for i := range [1..10] {
    fmt.Println(i)
}

Why it is wrong:

• Go has no 1..10 syntax.
• range does not generate integer sequences.

Use this instead:

for i := 1; i <= 10; i++ {
    fmt.Println(i)
}

Mistake 2: Off-by-one errors

Broken code:

for i := 1; i < 10; i++ {
    fmt.Println(i)
}

This prints 1 through 9, not 10.

Correct version:

for i := 1; i <= 10; i++ {
    fmt.Println(i)
}

for vs range

Numeric loop

for i := 1; i <= 10; i++ {
    fmt.Println(i)
}

Count from zero

for i := 0; i < n; i++ {
    // use i
}

Loop backwards

for i := 10; i >= 1; i-- {
    fmt.Println(i)
}

Custom step size

for i := 0; i <= 10; i += 2 {
    fmt.Println(i)
}

range over slice

nums := []int{10, 20, 30}
for index, value := range nums {
    fmt.Println(index, value)
}

Important rules

• Go has no built-in 1..10 syntax.
• Go has no built-in integer range type.

Why doesn't Go support 1..10 syntax?

Go keeps the language small and explicit. Numeric iteration is handled with for instead of special range syntax.

Can I use range to count from 1 to 10 in Go?

Not directly. range iterates over existing values such as slices, maps, strings, and channels.

Does Go have a built-in Range type like Ruby?

No. If you need a reusable range-like structure, you must build it yourself.

What is the idiomatic way to loop over numbers in Go?

Use a standard for loop:

for i := 1; i <= 10; i++ {
    fmt.Println(i)
}

When should I use range instead of for?

Use range when you already have a collection, such as a slice or map, and want to iterate through its elements.

How do I include the end number in a Go loop?

Use <= instead of <.

• for loop — the core looping construct in Go for counting and repetition.
• range keyword — used to iterate over slices, arrays, maps, strings, and channels.
• slices — often paired with range for collection iteration.
• arrays — fixed-size collections that can also be iterated with range.
• maps — another common type used with range.
• loop control with break and continue — useful when stopping early or skipping iterations.
• indexes and values — important for understanding what range returns.
• off-by-one errors — a common issue when writing numeric loops.