Go控制台输入and函数
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 运行结果 奔驰 品牌的汽车，颜色是黑色,正在鸣笛 宝马 品牌的汽车，颜色是白色,正在行驶
希望和悲伤，都是一缕光。总有一天，我们会再相遇。
