Looking for Go equivalent of scanf

I'm looking for the Go equivalent of scanf().
I tried with following code:

  1 package main
  2 
  3 import (
  4     "scanner"
  5     "os"
  6     "fmt"
  7 )
  8 
  9 func main() {
 10     var s scanner.Scanner
 11     s.Init(os.Stdin)
 12     s.Mode = scanner.ScanInts
 13     tok := s.Scan()
 14     for tok != scanner.EOF {
 15         fmt.Printf("%d ", tok)
 16         tok = s.Scan()
 17     }
 18     fmt.Println()
 19 }

I run it with input from a text with a line of integers.
But it always output -3 -3 ...

And how to scan a line composed of a string and some integers?
Changing the mode whenever encounter a new data type?

The Package documentation:

> Package scanner
>
> A general-purpose scanner for UTF-8
> encoded text.

But it seems that the scanner is not for general use.

Updated code:

func main() {
    n := scanf()
    fmt.Println(n)
    fmt.Println(len(n))
}

func scanf() []int {
    nums := new(vector.IntVector)
    reader := bufio.NewReader(os.Stdin)
    str, err := reader.ReadString('\n')
    for err != os.EOF {
        fields := strings.Fields(str)
        for _, f := range fields {
            i, _ := strconv.Atoi(f)
            nums.Push(i)
        }   
        str, err = reader.ReadString('\n')
    }   
    r := make([]int, nums.Len())
    for i := 0; i < nums.Len(); i++ {
        r[i] = nums.At(i)
    }   
    return r
}

Improved version:

package main

import (
    "bufio"
    "os"
    "io"
    "fmt"
    "strings"
    "strconv"
    "container/vector"
)

func main() {
    n := fscanf(os.Stdin)
    fmt.Println(len(n), n)
}

func fscanf(in io.Reader) []int {
    var nums vector.IntVector
    reader := bufio.NewReader(in)
    str, err := reader.ReadString('\n')
    for err != os.EOF {
        fields := strings.Fields(str)
        for _, f := range fields {
            if i, err := strconv.Atoi(f); err == nil {
                nums.Push(i)
            }   
        }   
        str, err = reader.ReadString('\n')
    }   
    return nums
}

Your updated code was much easier to compile without the line numbers, but it was missing the package and import statements.

Looking at your code, I noticed a few things. Here's my revised version of your code.

package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
	"strconv"
	"strings"
	"container/vector"
)

func main() {
	n := scanf(os.Stdin)
	fmt.Println()
	fmt.Println(len(n), n)
}

func scanf(in io.Reader) []int {
	var nums vector.IntVector
	rd := bufio.NewReader(os.Stdin)
	str, err := rd.ReadString('\n')
	for err != os.EOF {
		fields := strings.Fields(str)
		for _, f := range fields {
			if i, err := strconv.Atoi(f); err == nil {
				nums.Push(i)
			}
		}
		str, err = rd.ReadString('\n')
	}
	return nums
}

I might want to use any input file for scanf(), not just Stdin; scanf() takes an io.Reader as a parameter.

You wrote: nums := new(vector.IntVector), where type IntVector []int. This allocates an integer slice reference named nums and initializes it to zero, then the new() function allocates an integer slice reference and initializes it to zero, and then assigns it to nums. I wrote: var nums vector.IntVector, which avoids the redundancy by simply allocating an integer slice reference named nums and initializing it to zero.

You didn't check the err value for strconv.Atoi(), which meant invalid input was converted to a zero value; I skip it.

To copy from the vector to a new slice and return the slice, you wrote:

r := make([]int, nums.Len())
for i := 0; i < nums.Len(); i++ {
    r[i] = nums.At(i)
}
return r

First, I simply replaced that with an equivalent, the IntVector.Data() method: return nums.Data(). Then, I took advantage of the fact that type IntVector []int and avoided the allocation and copy by replacing that by: return nums.

Although it can be used for other things, the scanner package is designed to scan Go program text. Ints (-123), Chars('c'), Strings("str"), etc. are Go language token types.

package main

import (
	"fmt"
	"os"
	"scanner"
	"strconv"
)

func main() {
	var s scanner.Scanner
	s.Init(os.Stdin)
	s.Error = func(s *scanner.Scanner, msg string) { fmt.Println("scan error", msg) }
	s.Mode = scanner.ScanInts | scanner.ScanStrings | scanner.ScanRawStrings
	for tok := s.Scan(); tok != scanner.EOF; tok = s.Scan() {
		txt := s.TokenText()
		fmt.Print("token:", tok, "text:", txt)
		switch tok {
		case scanner.Int:
			si, err := strconv.Atoi64(txt)
			if err == nil {
				fmt.Print(" integer: ", si)
			}
		case scanner.String, scanner.RawString:
			fmt.Print(" string: ", txt)
		default:
			if tok >= 0 {
				fmt.Print(" unicode: ", "rune = ", tok)
			} else {
				fmt.Print(" ERROR")
			}
		}
		fmt.Println()
	}
}

This example always reads in a line at a time and returns the entire line as a string. If you want to parse out specific values from it you could.

package main

import (
	"fmt"
	"bufio"
	"os"
	"strings"
)

func main() {
	value :=	Input("Please enter a value: ")
	trimmed := strings.TrimSpace(value)
	fmt.Printf("Hello %s!\n", trimmed)
}

func Input(str string) string { 
        print(str) 
        reader := bufio.NewReader(os.Stdin) 
        input, _ := reader.ReadString('\n') 
        return input 
}

In a comment to one of my answers, you said:

> From the Language Specification: "When
> memory is allocated to store a value,
> either through a declaration or make()
> or new() call, and no explicit
> initialization is provided, the memory
> is given a default initialization".
> Then what's the point of new()?

If we run:

package main

import ("fmt")

func main() {
	var i int
	var j *int
	fmt.Println("i (a value) = ", i, "; j (a pointer) = ", j)
	j = new(int)
	fmt.Println("i (a value) = ", i, "; j (a pointer) = ", j, "; *j (a value) = ", *j)
}

The declaration var i int allocates memory to store an integer value and initializes the value to zero. The declaration var j *int allocates memory to store a pointer to an integer value and initializes the pointer to zero (a nil pointer); no memory is allocated to store an integer value. We see program output similar to:

i (a value) =  0 ; j (a pointer) =  <nil>

The built-in function new takes a type T and returns a value of type *T. The memory is initialized to zero values. The statement j = new(int) allocates memory to store an integer value and initializes the value to zero, then it stores a pointer to this integer value in j. We see program output similar to:

i (a value) =  0 ; j (a pointer) =  0x7fcf913a90f0 ; *j (a value) =  0

The latest release of Go (2010-05-27) has added two functions to the fmt package: Scan() and Scanln(). They don't take any pattern string. like in C, but checks the type of the arguments instead.

package main

import (
   "fmt"
   "os"
   "container/vector"
)

func main() {
    numbers := new(vector.IntVector)
    var number int
    n, err := fmt.Scan(os.Stdin, &number)
    for n == 1 && err == nil {
       numbers.Push(number)
       n, err = fmt.Scan(os.Stdin, &number)
    }
    fmt.Printf("%v\n", numbers.Data())
}