How to Convert float64 to int in Go

By the end of this page, you will understand how numeric type conversion works in Go, especially how to convert a float64 to an int using Go's built-in type conversion syntax. You will also learn what happens to the decimal part, when rounding is needed, common mistakes to avoid, and how this appears in real Go programs.

In Go, converting between numeric types does not require strconv or string formatting. Instead, Go provides explicit type conversion.

To convert a float64 to an int, you write:

i := int(f)

Here, f is a float64, and int(f) tells Go to create a new value of type int from f.

This matters because Go is a strongly typed language. It does not automatically convert between numeric types for you. Even though both float64 and int represent numbers, they are different types with different behavior:

• float64 can store decimal values
• int stores whole numbers only

When you convert from float64 to int, Go discards the fractional part. This is called truncation.

For example:

Think of a float64 as a measuring cup that can hold partial amounts, like 3.7 cups of water.

An int is like a box that only accepts whole items. If you pour 3.7 cups into a container that only stores whole numbers, the .7 part does not fit, so it gets dropped.

That is what Go does with:

int(3.7)

It keeps the whole-number part and throws away the fractional part.

If you want the nearest whole item instead, you must round first before putting it into the integer box.

The basic syntax is:

intValue := int(floatValue)

Example 1: Simple conversion

package main

import "fmt"

func main() {
	f := 12.75
	i := int(f)

	fmt.Println(f) // 12.75
	fmt.Println(i) // 12
}

i becomes 12 because the decimal part .75 is removed.

Example 2: Negative numbers

package main

import "fmt"

func main() {
	f := -8.99
	i := int(f)

	fmt.Println(i) // -8
}

This often surprises beginners. The result is -8, not -9, because conversion truncates toward zero.

Example 3: Round before converting

Consider this example:

package main

import "fmt"

func main() {
	f := 5.99
	i := int(f)
	fmt.Println(i)
}

Step by step:

1. f := 5.99

   • A variable f is created.
   • Its type is inferred as float64.
   • Its value is 5.99.

2. i := int(f)

   • Go converts f from float64 to int.
   • Since int cannot store decimals, the fractional part .99 is discarded.
   • i becomes 5.

3. fmt.Println(i)

Converting float64 to int is common when a program receives decimal values but later needs whole-number values.

Common situations

• User input processing

  • A form or API sends a decimal value like 42.0
  • Your code needs an integer for indexing, counting, or storage

• Working with measurements

  • A calculation returns 15.8
  • You only want the whole-unit portion, such as pixels, items, or seconds

• UI and graphics code

  • Layout calculations may use floating-point math
  • Screen coordinates often need integer values

• Data processing

  • A CSV or JSON file contains decimal numbers
  • You want to convert them into integer counters or IDs after validation

• Time and rate calculations

  • You compute averages or durations as floats
  • Later you need an integer number of seconds, retries, or batches

Example: pixels in a layout

width := 199.8
pixelWidth := int(width)

Example: API data cleanup

In real Go projects, developers usually use direct type conversion in small, focused places rather than building string-based conversions.

Common patterns

Validation before conversion

If the float must be within a safe range or must not contain a fractional part, validate first.

package main

import (
	"errors"
	"math"
)

func floatToIntExact(f float64) (int, error) {
	if math.Trunc(f) != f {
		return 0, errors.New("value has a fractional part")
	}
	return int(f), nil
}

This pattern is useful when decimals should be rejected instead of silently removed.

Rounding before storing

count := int(math.Round(result))

Used when a computed value should become the nearest whole number.

Guard clauses

func retries(delay float64) int {
	 delay <=  {
		 
	}
	 (delay)
}

1. Using strconv for numeric-to-numeric conversion

Broken idea:

s := fmt.Sprintf("%f", f)
i, _ := strconv.Atoi(s)

Why it is a mistake:

• unnecessary
• inefficient
• harder to read
• Atoi expects an integer string like "12", not "12.750000"

Correct approach:

i := int(f)

2. Expecting rounding instead of truncation

Broken assumption:

f := 9.9
fmt.Println(int(f)) // expected 10, actually 9

Fix:

i := int(math.Round(f))

3. Forgetting negative numbers truncate toward zero

Broken assumption:

f := -4.8
fmt.Println(int(f)) // expected -5, actually -4

// float64 to int
i := int(f)

Key rule

• float64 -> int truncates the fractional part

Examples

int(3.9)    // 3
int(3.1)    // 3
int(-3.9)   // -3

Round first if needed

int(math.Round(3.9)) // 4
int(math.Floor(3.9)) // 3
int(math.Ceil(3.1))  // 4

When to use what

• Use int(f) for direct numeric conversion
• Use strconv.ParseFloat() for strings like "3.14"
• Use strconv.Atoi() for strings like "42"

How do I convert a float64 to an int in Go?

Use explicit type conversion:

i := int(f)

Does Go round when converting float64 to int?

No. Go truncates the fractional part.

int(7.9) // 7

How do I round a float64 before converting in Go?

Use the math package:

i := int(math.Round(f))

Why should I not use strconv for this?

Because strconv is for converting between strings and numeric values. If you already have a float64, direct type conversion is simpler and idiomatic.

What happens with negative floats?

Go truncates toward zero.

• Type conversion in Go — This is the main concept behind converting between numeric types.
• float64 in Go — Helps you understand floating-point values and decimal precision.
• int in Go — Useful for learning how whole numbers are stored and used.
• math.Round, math.Floor, and math.Ceil — Important when truncation is not the behavior you want.
• strconv package — Related because it handles string-to-number and number-to-string conversions.
• Type inference in Go — Helps explain why f := 3.14 often becomes a float64.
• Numeric overflow and range — Important when converting large numbers to integer types.