go 语言控制台输入和go语言函数
go语言控制台输入及go的函数
目录
Go 控制台输入，数值转换，及随机数
不同基础类型之间的转化
对于不同的基础类型之间的转化，Go提供了strconv包。它实现了字符串与其他基本数据类型之间的转化。其中最常用的数值转化函数是 Atoi和Itoa，简单了解下它的使用。
Atoi方法可以将字符串类型的数值直接转化为int类型的数值。Itoa可以将int类型的数值转化为 string类型的值
控制台输入
复制//控制台输入一个数值，进行数据大小的比较(注意，要在终端，使用go run的方式运行)
package main
import "fmt"
func main() {
var (
number int
)
//控制台提示信息
fmt.Print("请输入一个整数:")
//控制台输入,输入的内容直接赋值给变量.
fmt.Scan(&number)
fmt.Println("数值是:", number)
fmt.Printf("数据类型是%T", number)
}
数值转换
复制//控制台输入一个数值，进行数据大小的比较
package main
import (
"fmt"
"strconv"
)
func main() {
var (
//定义数据类型
number string
)
//控制台提示信息
fmt.Print("请输入一个整数:")
//控制台输入,输入的内容直接赋值给变量.
fmt.Scan(&number) //如果输入10100，此时，输入进来的时字符串10100
fmt.Println("数值是:", number)
fmt.Printf("数据类型是%T\n", number)
//数据类型转换,string---->int
//Atoi函数，接收字符串类型数值，返回两个数值。第一个数值是转换后的，第二个数值是error错误提示信息
//我们可以使用空白标识符 _ 来接收错误信息
value, _ := strconv.Atoi(number)
fmt.Printf("转换后数据类型是%T\n", value)
//数值判断
if value > 100 {
fmt.Println("数值较大")
} else {
fmt.Println("数值较小")
}
}
//输出结果:
控制台输入 10100
请输入一个整数:10100
数值是: 10100
数据类型是string
转换后数据类型是int
数值较大
随机数
复制package main
import (
"fmt"
"math/rand"
"time"
)
/*随机数*/
func main() {
// 随机种子
rand.Seed(time.Now().Unix())
// 获取10个随机数
for i := 0; i < 10; i++ {
//左闭右开[0,100)
value := rand.Intn(100)
fmt.Println(value)
}
}
//输出结果:
89
9
86
95
91
80
6
81
24
90
实例
复制// 猜商品价格，商品高低，商品价格随机生成[0-300),如果你输入的价格大于商品价格，则提示价格过高
//如果输入的价格低于商品价格，则提示价格过低。知道猜中商品价格为止。并统计猜的次数
package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
var number, a int
rand.Seed(time.Now().Unix())
value := rand.Intn(301)
for {
fmt.Print("请输入商品价格:")
fmt.Scan(&number)
fmt.Println("你猜的价格是:", number)
a++
if number == value {
fmt.Println("你猜对了，商品价格是:", value)
fmt.Println("你一共猜了", a, "次")
break
}
if number < value {
fmt.Println("抱歉，你猜小了")
}
if number > value {
fmt.Println("抱歉，你猜大了")
}
}
}
复制// 猜商品价格，商品高低，商品价格随机生成[0-300),如果你输入的价格大于商品价格，则提示价格过高
//如果输入的价格低于商品价格，则提示价格过低。知道猜中商品价格为止。并统计猜的次数
package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
//number用来接收控制台输入，count用来统计用户猜的次数
var number, count int
//生成商品价格
rand.Seed(time.Now().Unix())
value := rand.Intn(301)
for {
fmt.Print("请输入商品价格:")
fmt.Scan(&number)
fmt.Println("你猜的价格是:", number)
//用户每猜一次，count值加一
count++
switch {
case number == value:
fmt.Printf("你猜对了，商品价格是:%d\n一共猜了%d次", value, count)
//用户猜对，则退出
//goto end 使用goto 或者return 都可以
return
case number > value:
fmt.Println("你猜大了")
default:
fmt.Println("你猜小了")
}
}
//end:
}
复制package main
import (
"bufio"
"fmt"
"os"
)
func main() {
fmt.Println("请输入内容:")
str1 := getInput()
fmt.Println(str1)
}
//缓冲区控制台输入
func getInput() string {
//创建缓冲区，并且bufio缓冲区从控制台读取输入信息
in := bufio.NewReader(os.Stdin)
//从缓冲区中读取字符串信息
str, _, err := in.ReadLine()
if err != nil {
return err.Error()
}
return string(str)
}
复制package main
import (
"bufio"
"fmt"
"os"
)
func main() {
fmt.Println("请输入内容:")
str1 := getStrInput()
fmt.Println(str1)
}
func getStrInput() string {
var str string
//创建bufio缓冲区，利用NewScanner加载控制台输入
in := bufio.NewScanner(os.Stdin)
if in.Scan() {
str = in.Text()
} else {
str = "not found"
}
return str
}
Go 语言函数
函数是基本的代码块，用于执行一个任务。
Go 语言最少有个 main() 函数。
你可以通过函数来划分不同功能，逻辑上每个函数执行的是指定的任务。
函数声明告诉了编译器函数的名称，返回类型，和参数。
Go 语言标准库提供了多种可动用的内置的函数。例如，len() 函数可以接受不同类型参数并返回该类型的长度。如果我们传入的是字符串则返回字符串的长度，如果传入的是数组，则返回数组中包含的元素个数。
- 内置函数：安装完go编译器就可以直接被调用的
- 用户自定义函数: 名字自行命名 （注意大小小控制权限)
- 插件中的函数：安装地方组件，才拥有的函数，
函数定义
Go 语言函数定义格式如下：
复制func function_name( [parameter list] ) [return_types] {
函数体
}
函数定义解析：
- func：函数由 func 开始声明
- function_name：函数名称，参数列表和返回值类型构成了函数签名。
- parameter list：参数列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也可以不包含参数。
- return_types：返回类型，函数返回一列值。return_types 是该列值的数据类型。有些功能不需要返回值，这种情况下 return_types 不是必须的。
- 函数体：函数定义的代码集合。
复制//无参，无返回值
func test (){
}
复制//传参，有返回值
//传递的参数的参数类型，要和函数定义的参数值类型相同。定义了int 类型数据，就只能传递int类型数据进入
funt test(a int,b int) int {
//注意，return 定义的返回值，要和函数定义的返回值类型一样。比如这里，定义了返回值类型为int,则return 返回值就只能是int
return n
}
复制//传参，有多个返回值
funt result(a int,b int)(int,int){
return a+b,a-b
}
实例
以下实例为 max() 函数的代码，该函数传入两个整型参数 num1 和 num2，并返回这两个参数的最大值：
复制/* 函数返回两个数的最大值 */
// 小括号和大括号之间的int ，是定义函数返回值的数据类型
func max(num1, num2 int) int {
/* 声明局部变量 */
var result int
if (num1 > num2) {
result = num1
} else {
result = num2
}
//return 返回值，要和定义的返回值数据类型相同
return result
}
函数调用
当创建函数时，你定义了函数需要做什么，通过调用该函数来执行指定任务。
调用函数，向函数传递参数，并返回值，例如：
复制package main
import "fmt"
func main() {
/* 定义局部变量 */
var a int = 100
var b int = 200
var ret int
/* 调用函数并返回最大值 */
ret = max(a, b)
fmt.Printf( "最大值是 : %d\n", ret )
}
/* 函数返回两个数的最大值 */
func max(num1, num2 int) int {
/* 定义局部变量 */
var result int
if (num1 > num2) {
result = num1
} else {
result = num2
}
return result
}
//输出结果:
最大值是 : 200
复制package main
import "fmt"
func main() {
Test(10, 20, "两数求和值为:")
}
//多参数传入
func Test(a, b int, c string) {
fmt.Println(c, a+b)
}
//输出为:
两数求和值为: 30
函数返回多个值
Go 函数可以返回多个值，例如：
复制//示例：函数返回多个值
package main
import "fmt"
func main() {
a, b := mutil_value(10, 20) //10，20 为实际参数
fmt.Printf("两个数项加是:%d,两个数相乘是%d", a, b)
}
//num1，num2 形式参数，定义传入参数的数据类型
func mutil_value(num1, num2 int) (int, int) {
result1 := num1 + num2
result2 := num1 * num2
return result1, result2
}
//输出结果:
两个数项加是:30,两个数相乘是200
复制package main
import "fmt"
func main() {
//函数有多个返回值，但是只想接收一个，可以使用空白标识符
_, b := Test(10, 20)
fmt.Printf("两数积是%d", b)
}
//多个返回值
func Test(a, b int) (int, int) {
result1 := a + b
result2 := a * b
return result1, result2
}
//输出结果
两数积是200
函数参数
函数如果使用参数，该变量可称为函数的形参。
形参就像定义在函数体内的局部变量。
调用函数，可以通过两种方式来传递参数：
| 传递类型 | 描述 |
|---|---|
| 值传递 | 值传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。 |
| 引用传递 | 引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。 |
默认情况下，Go 语言使用的是值传递，即在调用过程中不会影响到实际参数。
Go 语言函数值传递值
传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。
默认情况下，Go 语言使用的是值传递，即在调用过程中不会影响到实际参数。
复制package main
import "fmt"
func main() {
var (
num1 = 10
num2 = 20
)
fmt.Println("交换前主函数")
fmt.Printf("num1=%d\nnum2=%d\n", num1, num2)
//调用函数，传入实参
swap(num1, num2)
fmt.Println("交换后主函数")
fmt.Printf("num1=%d\nnum2=%d\n", num1, num2)
}
//两个数值交换
func swap(a, b int) {
a, b = b, a
fmt.Println("swap函数内", a, b)
}
//输出结果
交换前主函数
num1=10
num2=20
swap函数内 20 10
交换后主函数
num1=10
num2=20
程序中使用的是值传递, 所以两个值并没有实现交互，我们可以使用 引用传递来实现交换效果。
Go 语言函数引用传递值
引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。
以下我们通过使用引用传递来调用 swap() 函数：
复制package main
import "fmt"
func main() {
var (
num1 = 11
num2 = 22
)
fmt.Println("交换前两数值")
fmt.Printf("num1=%d\nnum2=%d\n", num1, num2)
swap(&num1, &num2)
fmt.Println("交换后两数值")
fmt.Printf("num1=%d\nnum2=%d\n", num1, num2)
}
//引用类型传参
func swap(a, b *int) {
*a, *b = *b, *a
}
//输出结果:
交换前两数值
num1=11
num2=22
交换后两数值
num1=22
num2=11
函数用法
| 函数用法 | 描述 |
|---|---|
| 函数作为另外一个函数的实参 | 函数定义后可作为另外一个函数的实参数传入 |
| 闭包 | 闭包是匿名函数，可在动态编程中使用 |
| 方法 | 方法就是一个包含了接受者的函数 |
Go 语言函数作为实参与go语言数学包
Go 语言可以很灵活的创建函数，并作为另外一个函数的实参。以下实例中我们在定义的函数中初始化一个变量，该函数仅仅是为了使用内置函数 math.sqrt()，实例为：
复制package main
import (
"fmt"
"math"
)
func main() {
//函数变量(匿名函数)
result := func(x float64) float64 {
return math.Sqrt(x)
}
//直接使用变量名调用函数
fmt.Println(result(9))
}
//输出结果:
3
go语言数学包
复制//go语言数学包
package main
import (
"fmt"
"math"
)
func main() {
//数学包
fmt.Println("-10的绝对值:", math.Abs(-10))
fmt.Println("5.2向上取整:", math.Ceil(5.2))
fmt.Println("5.8向下取整:", math.Floor(5.8))
fmt.Println("11除以3的余数:", math.Mod(11, 3))
fmt.Println("取整数,取小数")
fmt.Println(math.Modf(5.26))
fmt.Println("3的2次方", math.Pow(3, 2))
fmt.Println("10的4次方", math.Pow10(4))
fmt.Println("27的开立方", math.Cbrt(27))
fmt.Println("圆周率", math.Pi)
}
//输出结果:
-10的绝对值: 10
5.2向上取整: 6
5.8向下取整: 5
11除以3的余数: 2
取整数,取小数
5 0.2599999999999998
3的2次方 9
10的4次方 10000
27的开立方 3
圆周率 3.141592653589793
回调函数
回调函数作为初始函数的参数传入
当调用初始函数的时候，自动调用回调函数
初始函数---->回调函数
复制package main
import "fmt"
//声明形式函数
type cback func(int) int
func main() {
//对回调函数进行了隐匿，起到了安全保护作用，提高程序运行效率
test_back(1, call_back)
}
//测试函数,用来调用回调函数
//将声明的形式函数，作为形参
func test_back(x int, f cback) {
fmt.Println("test_back函数，语句1")
f(x)
fmt.Println("test_back函数，语句2")
}
//回调函数
func call_back(a int) int {
fmt.Println("回调函数call_back:", a)
return a
}
//输出结果：
test_back函数，语句1
回调函数call_back: 1
test_back函数，语句2
复制package main
import (
"fmt"
)
//声明形式函数
type cback func(int) int
func main() {
//对回调函数进行了隐匿，起到了安全保护作用，提高程序运行效率
test_back(1, call_back)
test_back(2, func(b int) int {
fmt.Println("匿名回调函数：", b)
return b
})
}
//测试函数,用来调用回调函数
//将声明的形式函数，作为形参
func test_back(x int, f cback) {
fmt.Println("test_back函数，语句1")
f(x)
fmt.Println("test_back函数，语句2")
}
//回调函数
func call_back(a int) int {
fmt.Println("回调函数call_back:", a)
return a
}
//输出结果:
test_back函数，语句1
回调函数call_back: 1
test_back函数，语句2
test_back函数，语句1
匿名回调函数： 2
test_back函数，语句2
Go 语言函数闭包
闭包：一个函数与其相关的引用环境组成的一个整体
Go 语言支持匿名函数，可作为闭包。匿名函数是一个"内联"语句或表达式。匿名函数的优越性在于可以直接使用函数内的变量，不必申明。
复制//演示闭包
package main
import "fmt"
//函数close_package, 其返回值是 func(int) int
func close_package() func(int) int {
//闭包开始
//定义一个变量 n
var n int = 10
// return 返回的是一个匿名函数.
//这个匿名函数引用了其函数本身外的变量n.因此,这个函数和 n 形成了一个整体,构成了闭包
return func(x int) int {
//调用函数外部的变量n
n += x
return n
}
//闭包结束
}
func main() {
f := close_package()
fmt.Println(f(1)) //11
fmt.Println(f(2)) //13
fmt.Println(f(3)) //16
}
//输出结果:
11
13
16
- 一个函数close_package ,其返回值是一个函数
- 作为返回值的函数,引用了外部函数close_package里定义的变量n .这个外部函数的变量n 就和作为返回值的函数,形成了一个整体,构成了闭包.
- 当反复调用外部函数close_package 里的变量n 时,n 只会初始化一此,因此,每调用一次,就进行累计
复制package main
import "fmt"
func main() {
number1 := close_package()
fmt.Println("number1 闭包执行")
fmt.Println(number1())
fmt.Println(number1())
fmt.Println(number1())
number2 := close_package()
fmt.Println("number2 闭包执行")
fmt.Println(number2())
fmt.Println(number2())
fmt.Println(number2())
}
//匿名函数作为close_package 函数的返回值，
func close_package() func() int {
//在函数close_package 里定义变量i
i := 1
// 返回 执行匿名函数 闭包结构
return func() int {
//虽然变量i 是在此匿名函数外部定义的，但是匿名函数内部依旧可见。
//匿名函数引用函数外变量.因此，匿名函数和变量i 形成了一个整体，构成闭包
i++
return i
}
}
//输出结果：
number1 闭包执行
2
3
4
number2 闭包执行
2
3
4
Go 语言函数方法
Go 语言中同时有函数和方法。一个方法就是一个包含了接受者的函数，接受者可以是命名类型或者结构体类型的一个值或者是一个指针。所有给定类型的方法属于该类型的方法集。语法格式如下：
复制func (variable_name variable_data_type) function_name() [return_type]{
/* 函数体*/
}
下面定义一个结构体类型和该类型的一个方法：
复制package main
import (
"fmt"
)
/* 定义结构体 */
type Circle struct {
radius float64
}
func main() {
var c1 Circle
c1.radius = 10.00
fmt.Println("圆的面积 = ", c1.getArea())
}
//该 method 属于 Circle 类型对象中的方法,只有Circle 能调用
//c 为Circle的实例对象
func (c Circle) getArea() float64 {
//c.radius 即为 Circle 类型对象中的属性
return 3.14 * c.radius * c.radius
}
//输出结果:
圆的面积 = 314
在example1目录下,有两个目录car 和 main. car 目录下有car.go 文件, main目录下有main.go文件
复制// car 包,car.go定义结构体和方法
package car
import "fmt"
//定义结构体
type Car struct {
//定义属性
Name string
Color string
}
//函数方法
func (c Car) Call() {
// (c Car ) 等同于 c := new(Car)
fmt.Printf("%s 品牌的汽车，颜色是%s,正在鸣笛\n", c.Name, c.Color)
}
func (c Car) Run() {
fmt.Printf("%s 品牌的汽车，颜色是%s,正在行驶\n", c.Name, c.Color)
}
复制//main包,main.go 加载car 包,调用结构体,进行实例化
package main
import "dev_code/day9/example1/car"
func main() {
//实例化
c1 := new(car.Car)
c1.Name = "奔驰"
c1.Color = "黑色"
c1.Call()
c2 := new(car.Car)
c2.Name = "宝马"
c2.Color = "白色"
c2.Run()
}
// main.go 运行结果
奔驰 品牌的汽车，颜色是黑色,正在鸣笛
宝马 品牌的汽车，颜色是白色,正在行驶
【推荐】国内首个AI IDE，深度理解中文开发场景，立即下载体验Trae
【推荐】编程新体验，更懂你的AI，立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包，你的智能百科全书，全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell：AI 加持，快人一步
· winform 绘制太阳，地球，月球 运作规律
· AI与.NET技术实操系列（五）：向量存储与相似性搜索在 .NET 中的实现
· 超详细：普通电脑也行Windows部署deepseek R1训练数据并当服务器共享给他人
· 上周热点回顾（3.3-3.9）
· AI 智能体引爆开源社区「GitHub 热点速览」