GoLang之控制台输入输出

1.源码

1.1Scan

Scan从标准输入扫描文本，将成功读取的空白分隔的值保存进成功传递给本函数的参数。换行视为空白。返回成功扫描的条目个数和遇到的任何错误。如果读取的条目比提供的参数少，会返回一个错误报告原因。

func Scan(a ...interface{}) (n int, err error)
1

1.2Scanf

Scan从标准输入扫描文本，将成功读取的空白分隔的值保存进成功传递给本函数的参数。换行视为空白。返回成功扫描的条目个数和遇到的任何错误。如果读取的条目比提供的参数少，会返回一个错误报告原因。

func Sscan(str string, a ...interface{}) (n int, err error)
1

1.3Scanln

Scanln类似Scan，但会在换行时才停止扫描。最后一个条目后必须有换行或者到达结束位置。

func Scanln(a ...interface{}) (n int, err error)
1

2.函数使用

2.1scan输入单个参数时，遇到回车会停止(多行)

package main

import (
	"fmt"
)

func main() {
	var t1 int
	var t2 int
	fmt.Scan(&t1)
	fmt.Scan(&t2)
	fmt.Println(t1)
	fmt.Println(t2)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.2scan输入单个参数时，遇到空格会停止(多行)

package main

import (
	"fmt"
)

func main() {
	var t1 int
	var t2 int
	fmt.Scan(&t1)
	fmt.Scan(&t2)
	fmt.Println(t1)
	fmt.Println(t2)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.3scan输入多个参数时，参数之间用回车(单行)

package main

import (
	"fmt"
)

func main() {
	var t1 int
	var t2 int
	fmt.Scan(&t1, &t2)
	fmt.Println(t1)
	fmt.Println(t2)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.4scan输入多个参数时，参数之间用回车(多行)

package main

import (
	"fmt"
)

func main() {
	var t1 int
	var t2 int
	var t3 int
	var t4 int
	fmt.Scan(&t1, &t2)
	fmt.Scan(&t3, &t4)

	fmt.Println(t1)
	fmt.Println(t2)
	fmt.Println(t3)
	fmt.Println(t4)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

2.5scan输入多个参数时，参数之间用空格(单行)

package main

import (
	"fmt"
)

func main() {
	var t1 int
	var t2 int
	fmt.Scan(&t1, &t2)
	fmt.Println(t1)
	fmt.Println(t2)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.6scan输入多个参数时，参数之间用空格(多行)

package main

import (
	"fmt"
)

func main() {
	var t1 int
	var t2 int
	var t3 int
	var t4 int
	fmt.Scan(&t1, &t2)
	fmt.Scan(&t3, &t4)

	fmt.Println(t1)
	fmt.Println(t2)
	fmt.Println(t3)
	fmt.Println(t4)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

2.7scanln输入单个参数时，遇到回车会停止(多行)

package main

import (
	"fmt"
)

func main() {
	var t1 int
	var t2 int
	fmt.Scanln(&t1)
	fmt.Scanln(&t2)
	fmt.Println(t1)
	fmt.Println(t2)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.8scanln输入单个参数时，遇到空格会停止(多行)

package main

import (
	"fmt"
)

func main() {
	var t1 int
	var t2 int
	fmt.Scanln(&t1)
	fmt.Scanln(&t2)
	fmt.Println(t1)
	fmt.Println(t2)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.9scanln输入多个参数时，参数之间不能用回车(单行)

package main

import (
	"fmt"
)

func main() {
	var t1 int
	var t2 int
	fmt.Scanln(&t1, &t2)
	fmt.Println(t1)
	fmt.Println(t2)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.10scanln输入多个参数时，参数之间不能用回车(多行)

package main

import (
	"fmt"
)

func main() {
	var t1 int
	var t2 int
	var t3 int
	var t4 int
	fmt.Scanln(&t1, &t2)
	fmt.Scanln(&t1, &t2)
	fmt.Println(t1)
	fmt.Println(t2)
	fmt.Println(t3)
	fmt.Println(t4)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

2.11scanln输入多个参数时，参数之间用空格(单行)

package main

import (
	"fmt"
)

func main() {
	var t1 int
	var t2 int
	fmt.Scanln(&t1, &t2)
	fmt.Println(t1)
	fmt.Println(t2)
}
1
2
3
4
5
6
7
8
9
10
11
12
13

2.12scanln输入多个参数时，参数之间用空格(多行)

package main

import (
	"fmt"
)

func main() {
	var t1 int
	var t2 int
	var t3 int
	var t4 int
	fmt.Scanln(&t1, &t2)
	fmt.Scanln(&t3, &t4)
	fmt.Println(t1)
	fmt.Println(t2)
	fmt.Println(t3)
	fmt.Println(t4)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

2.13expected integer

package main

import (
	"fmt"
)

func main() {
	var t int
	n, err := fmt.Scan(&t)
	fmt.Println(n)
	fmt.Println(err)
}

1
2
3
4
5
6
7
8
9
10
11
12
13

3.例题

package main

import (
	"fmt"
	"io"
	"math"
)

func main() {
	n := 0
	m := 0
	for {
		_, err := fmt.Scanf("%d %d", &n, &m)
		if err != nil {
			if err == io.EOF {
				break
			}
		} else {
			fmt.Printf("%.2f\n", Sum(n, m))
		}
	}

}
func Sum(n, m int) float64 {
	var sum float64
	var tmp float64
	tmp = float64(n)
	i := 1
	for i <= m {
		sum = sum + tmp
		i++
		tmp = math.Sqrt(tmp)
	}
	return sum
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

package main

import (
	"fmt"
	"io"
	"math"
)

func main() {
	n := 0
	m := 0
	for {
		_, err := fmt.Scanf("%d%d", &n, &m)
		if err != nil {
			if err == io.EOF {
				break
			}
		} else {
			fmt.Printf("%.2f\n", Sum(n, m))
		}
	}

}
func Sum(n, m int) float64 {
	var sum float64
	var tmp float64
	tmp = float64(n)
	i := 1
	for i <= m {
		sum = sum + tmp
		i++
		tmp = math.Sqrt(tmp)
	}
	return sum
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

4.每行输入两个int数字，无限输入行数

需要注意的是这里的%d与%d之间有没有空格都无所谓，我们在控制台输入的时候两个数字之间都必须得有空格分隔，然后按会回车后便会输出答案

package main

import "fmt"
import "io"

func main() {
	a := 0
	b := 0
	for {
	    
		_, err := fmt.Scanf("%d%d", &a, &b)
		if err != nil {
			if err == io.EOF {
				break
			}
		} else {
			fmt.Printf("%d\n", a+b)
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

package main

import "fmt"
import "io"

func main() {
	a := 0
	b := 0
	for {
		_, err := fmt.Scanf("%d %d", &a, &b)
		if err != nil {
			if err == io.EOF {
				break
			}
		} else {
			fmt.Printf("%d\n", a+b)
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

5.每行输入两个int数字，指定输入行数

题目：
1.输入描述:
输入第一行包括一个数据组数t(1 <= t <= 100)
接下来每行包括两个正整数a,b(1 <= a, b <= 1000)

2.输出描述:
输出a+b的结果
3.输入输出例子:
2
1 5
6
10 20
30
…

package main

import(
    "fmt"
)

func main(){
    var t,a,b int
    fmt.Scanln(&t)
    for i:=0;i<t;i++{
        fmt.Scanln(&a,&b)
        fmt.Println(a+b)
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

6.每行为容量为2的数组赋值，无限输入行数

package main

import (
	"fmt"
)

func main() {
	a := [2]int{}
	for {
		var sum int
		for i := 0; i < 2; i++ {
			fmt.Scan(&a[i])
		}
		for i := 0; i < 2; i++ {
			sum += a[i]
		}
		fmt.Println(sum)
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

package main

import (
	"fmt"
)

func main() {
	for i := 0; i < 5; i++ {
		var sum int
		sum = sum + i
		fmt.Println(sum)

	}
	/*
		输出：
		0
		1
		2
		3
		4
	*/
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

7.每行为指定容量的切片赋值，无限输入行数，有结束标志

1.输入描述:
输入数据包括多组。
每组数据一行
n指定切片的容量
n为0的时候结束输入
求和n个正整数。
2.输出描述:
每组数据输出求和的结果
3.输入例子1:
4
1 2 3 4
10
5
1 2 3 4 5
15
0
结束

package main

import (
	"fmt"
)

func main() {
	var t int
	for {
        var sum int
        
		fmt.Scan(&t)
		if t == 0 {
			break
		} else {
			a := make([]int, t)
			for i := 0; i < t; i++ {
				fmt.Scan(&a[i])
			}
			for i := 0; i < t; i++ {
				sum += a[i]
			}
		}
		fmt.Println(sum)
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

8.每行为指定容量的切片赋值，无限输入行数，无结束标志，输入错误时候就结束

需要注意的是，对于fmt.Scan(&t)来说只有输入为错误的时候才会分会字节数为0，当我们一直按回车的时候是不会返回字节数为0的

package main

import (
	"fmt"
)

func main() {
	var t int
	for {
        var sum int
        n,_ := fmt.Scan(&t)
		if n == 0 {
			break
		} else {
			a := make([]int, t)
			for i := 0; i < t; i++ {
				fmt.Scan(&a[i])
			}
			for i := 0; i < t; i++ {
				sum += a[i]
			}
		}
		fmt.Println(sum)
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

9.指定矩阵长宽，进行输入

package main

import (
	"fmt"
)

func main() {
	var m, n int
	fmt.Scanln(&m, &n)

	res := make([][]int, m)
	for i := range res {
		res[i] = make([]int, n)
	}
	for i := 0; i < m; i++ {
		for j := 0; j < n; j++ {
			fmt.Scan(&res[i][j])
		}
	}
	fmt.Println(res)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

10.每行数字数量不固定，且不知道数量

package main

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

func main() {
	inputs := bufio.NewScanner(os.Stdin)
	for inputs.Scan() { //每次读入一行
		data := strings.Split(inputs.Text(), " ") //通过空格将他们分割，并存入一个字符串切片
		var sum int
		for i := range data {
			val, _ := strconv.Atoi(data[i]) //将字符串转换为int
			sum += val
		}
		fmt.Println(sum)
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23