ZetCode

Golang fmt.Sscan function

last modified May 8, 2025

This tutorial explains how to use the fmt.Sscan function in Go. We'll cover string parsing basics with practical examples of formatted input.

The fmt.Sscan function scans a string and stores successive space-separated values into arguments. It returns the number of items successfully scanned and any error encountered.

In Go, fmt.Sscan is useful for parsing simple string data into variables. It's part of the fmt package which handles formatted I/O operations.

Basic fmt.Sscan example

The simplest use of fmt.Sscan parses space-separated values from a string. This example demonstrates basic string scanning.
Note: Values must be space-separated in the input string.

basic_sscan.go
package main

import (
    "fmt"
)

func main() {
    var name string
    var age int
    
    input := "John 42"
    
    n, err := fmt.Sscan(input, &name, &age)
    if err != nil {
        fmt.Println("Error scanning:", err)
        return
    }
    
    fmt.Printf("Scanned %d values: %s is %d years old\n", n, name, age)
}

The code scans two values from the input string into variables. The function returns the count of successfully scanned items and any error.

Scanning multiple values

fmt.Sscan can parse multiple values of different types from a string. This example shows scanning various data types.

multiple_values.go
package main

import (
    "fmt"
)

func main() {
    var (
        name   string
        age    int
        height float64
        active bool
    )
    
    input := "Alice 25 1.68 true"
    
    n, err := fmt.Sscan(input, &name, &age, &height, &active)
    if err != nil {
        fmt.Println("Error scanning:", err)
        return
    }
    
    fmt.Printf("Scanned %d values:\n", n)
    fmt.Printf("Name: %s\nAge: %d\nHeight: %.2f\nActive: %t\n", 
        name, age, height, active)
}

The example scans string, integer, float, and boolean values from a single string. Each value must match the expected type in the variable.

Handling scanning errors

When input doesn't match expected types, fmt.Sscan returns an error. This example demonstrates error handling.

error_handling.go
package main

import (
    "fmt"
)

func main() {
    var count int
    var price float64
    
    inputs := []string{
        "5 9.99",    // valid
        "five 9.99",  // invalid
        "5 nine",     // invalid
    }
    
    for _, input := range inputs {
        n, err := fmt.Sscan(input, &count, &price)
        if err != nil {
            fmt.Printf("Error scanning '%s': %v\n", input, err)
            continue
        }
        fmt.Printf("Scanned %d items from '%s': %d, %.2f\n", 
            n, input, count, price)
    }
}

The code attempts to scan different input strings. Invalid inputs produce errors that we handle gracefully in the program.

Scanning into a struct

We can use fmt.Sscan to populate struct fields from a string. This example shows structured data parsing.

struct_scanning.go
package main

import (
    "fmt"
)

type Person struct {
    Name string
    Age  int
    City string
}

func main() {
    var p Person
    
    input := "Bob 35 NewYork"
    
    n, err := fmt.Sscan(input, &p.Name, &p.Age, &p.City)
    if err != nil {
        fmt.Println("Error scanning:", err)
        return
    }
    
    fmt.Printf("Scanned %d fields into struct:\n%+v\n", n, p)
}

The example scans values directly into a struct's fields. The struct must have exported fields (capitalized names) to be accessible.

Using Sscan with variadic parameters

We can create flexible scanning functions using variadic parameters with fmt.Sscan. This example shows a reusable scanning function.

variadic_scanning.go
package main

import (
    "fmt"
)

func scanValues(input string, values ...interface{}) error {
    n, err := fmt.Sscan(input, values...)
    if err != nil {
        return err
    }
    if n != len(values) {
        return fmt.Errorf("expected %d values, got %d", len(values), n)
    }
    return nil
}

func main() {
    var id int
    var name string
    var score float64
    
    input := "101 Alice 95.5"
    
    err := scanValues(input, &id, &name, &score)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    
    fmt.Printf("ID: %d, Name: %s, Score: %.1f\n", id, name, score)
}

The scanValues function accepts any number of pointers to scan into. It provides additional validation of the scanned item count.

Scanning with custom delimiters

While fmt.Sscan uses spaces by default, we can pre-process strings to handle other delimiters. This example shows comma-separated parsing.

custom_delimiters.go
package main

import (
    "fmt"
    "strings"
)

func main() {
    var item string
    var quantity int
    var price float64
    
    input := "apple,5,1.99"
    
    // Replace commas with spaces
    normalized := strings.ReplaceAll(input, ",", " ")
    
    n, err := fmt.Sscan(normalized, &item, &quantity, &price)
    if err != nil {
        fmt.Println("Error scanning:", err)
        return
    }
    
    fmt.Printf("Scanned %d items: %d %s at $%.2f each\n", 
        n, quantity, item, price)
}

The code converts commas to spaces before scanning. This technique works for simple cases but consider strings.Split for complex parsing.

Advanced scanning with Sscanf

For more control over parsing, fmt.Sscanf offers formatted scanning. This example compares Sscan and Sscanf.

advanced_scanning.go
package main

import (
    "fmt"
)

func main() {
    var a, b, c int
    
    input := "10-20-30"
    
    // Using Sscan (requires space separation)
    n1, err1 := fmt.Sscan(strings.ReplaceAll(input, "-", " "), &a, &b, &c)
    fmt.Printf("Sscan: %d,&v → %d %d %d\n", n1, err1, a, b, c)
    
    // Using Sscanf with format string
    n2, err2 := fmt.Sscanf(input, "%d-%d-%d", &a, &b, &c)
    fmt.Printf("Sscanf: %d,&v → %d %d %d\n", n2, err2, a, b, c)
}

fmt.Sscanf provides more precise control with format specifiers. Choose between Sscan and Sscanf based on your parsing needs.

Source

Go fmt package documentation

This tutorial covered the fmt.Sscan function in Go with practical examples of string parsing and formatted input handling.

Author

My name is Jan Bodnar, and I am a passionate programmer with extensive programming experience. I have been writing programming articles since 2007. To date, I have authored over 1,400 articles and 8 e-books. I possess more than ten years of experience in teaching programming.

List all Golang tutorials.