Ищем Go-эквивалент scanf

Question

Я ищу эквивалент scanf() в Go.Я попробовал следующий код:

  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 }

Я запускаю его с вводом текста со строкой целых чисел.Но всегда выдает -3 -3...

А как просканировать строку, состоящую из строки и нескольких целых чисел?Изменение режима всякий раз, когда встречается новый тип данных?

Документация пакета:

Сканер упаковки

Сканер общего назначения для кодированного UTF-8 текста.

Но похоже сканер не для общего пользования.

Обновленный код:

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
}

Улучшенная версия:

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
}

Answer 1

Ваш обновленный код было гораздо проще компилировать без номеров строк, но в нем отсутствовали операторы package и import.

Глядя на ваш код, я заметил несколько вещей.Вот моя исправленная версия вашего кода.

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
}

Возможно, я захочу использовать любой входной файл для scanf(), не просто Stdin; scanf() принимает io.Reader в качестве параметра.

Вы написали: nums := new(vector.IntVector), где type IntVector []int.При этом выделяется целочисленная ссылка на срез с именем nums и инициализирует его нулем, затем new() функция выделяет ссылку на целочисленный срез и инициализирует ее нулем, а затем присваивает ее nums.Я написал: var nums vector.IntVector, что позволяет избежать избыточности за счет простого выделения целочисленной ссылки на срез с именем nums и инициализируем его нулем.

Вы не проверили err ценность для strconv.Atoi(), что означало, что недопустимый ввод был преобразован в нулевое значение;Я пропускаю это.

Чтобы скопировать вектор в новый срез и вернуть срез, вы написали:

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

Во-первых, я просто заменил это эквивалентом, IntVector.Data() метод: return nums.Data().Тогда я воспользовался тем, что type IntVector []int и избежал выделения и копирования, заменив это на: return nums.

Answer 2

Хотя его можно использовать и для других целей, пакет сканера предназначен для сканирования текста программы Go.Целые числа (-123), символы («c»), строки («str») и т. д.являются типами токенов языка Go.

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()
    }
}

Answer 3

Этот пример всегда считывает построчно и возвращает всю строку в виде строки.Если вы хотите проанализировать из него определенные значения, вы можете это сделать.

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 
}

Answer 4

В комментарии к одному из моих ответов вы сказали:

Из спецификации языка:«Когда память выделяется для хранения значения, либо посредством объявления, либо для вызова () или нового (), и явную инициализацию не предоставляется, памяти дается инициализация по умолчанию».Тогда какой смысл в new()?

Если мы запустим:

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)
}

Декларация var i int выделяет память для хранения целочисленного значения и инициализирует это значение нулем.Декларация var j *int выделяет память для хранения указателя на целочисленное значение и инициализирует указатель нулем (нулевой указатель);память для хранения целочисленного значения не выделяется.Мы видим вывод программы, похожий на:

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

Встроенная функция new принимает тип T и возвращает значение типа *T.Память инициализируется нулевыми значениями.Заявление j = new(int) выделяет память для хранения целочисленного значения и инициализирует это значение нулем, затем сохраняет указатель на это целочисленное значение в j.Мы видим вывод программы, похожий на:

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

Answer 5

В последней версии Go (27 мая 2010 г.) в fmt упаковка: Scan() и Scanln().Они не принимают никакой строки шаблона.как в C, но вместо этого проверяет тип аргументов.

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())
}