Je cherche l'équivalent aller de scanf ().
J'ai essayé avec le code suivant: Je l'exécute avec une entrée d'un texte avec une ligne d'entiers.
Mais il en résulte toujours -3 -3 ... p> et comment numériser une ligne composée d'une chaîne et de certains entiers?
Changer le mode chaque fois que rencontrez un nouveau type de données? P> La documentation du package: P> scanner de package p>
Scanner à usage général pour UTF-8
texte codé. p>
BlockQuote> Mais il semble que le scanner ne soit pas à usage général. p> code mis à jour: p> version améliorée: p >
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
}
5 Réponses :
Bien qu'il puisse être utilisé pour d'autres choses, le package Scanner est conçu pour analyser le texte du programme Go. INTS (-123), caractères ('c'), chaînes ("str"), etc. sont des types de jetons de langue.
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()
}
}
Cet exemple se lit toujours dans une ligne à la fois et renvoie toute la ligne en tant que chaîne. Si vous voulez analyser des valeurs spécifiques de votre part, vous le pouvez.
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
}
Votre code mis à jour était beaucoup plus facile à compiler sans les numéros de ligne, mais il manquait les relevés d'emballage et d'importation.
Regardant votre code, j'ai remarqué quelques choses. Voici ma version révisée de votre code. P>
r := make([]int, nums.Len())
for i := 0; i < nums.Len(); i++ {
r[i] = nums.At(i)
}
return r
Merci! 1. Dans la spécification linguistique: «Lorsque la mémoire est allouée pour stocker une valeur, via une déclaration ou une déclaration () ou un nouvel appel (), et aucune initialisation explicite n'est fournie, la mémoire est donnée une initialisation par défaut». Alors quel est le point de nouvelle ()? 2. J'ai remarqué "Tapez Intvector [] INT" pour la première fois. Go est si différente de C ++. Et comme IntTvector est de type int [], est la fonction de fonction () redondante?
Dans un commentaire à l'une de mes réponses, vous avez dit:
Pour obtenir de bonnes réponses, vous devez rendre vos questions faciles à répondre. Par exemple, le code qui peut facilement être copié, collé et compilé. Le go compliant n'accepte pas les numéros de ligne; Ne les mettez pas dans votre exemple de code.
Peut-être que cela n'existait pas quand posté à l'origine, mais aller a FMT.Scanf qui fonctionne comme C Scanf à partir de Stdin: Var Number Int FMT.SCANF ("% D", & Number)
Oh mon Dieu! J'ai essayé de nombreuses heures pour obtenir un bon lecteur de Stdin. Homme, je ne pouvais tout simplement pas comprendre comment l'écrire. Merci beaucoup pour avoir posté votre code