本文主要是介绍go 语言控制台输入和go语言函数，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

go语言控制台输入及go的函数

• Go 控制台输入，数值转换，及随机数
  • 控制台输入
  • 数值转换
  • 随机数
  • 实例
• Go 语言函数
  • 函数定义
    • 实例
  • 函数调用
  • 函数返回多个值
  • 函数参数
    • Go 语言函数值传递值
    • Go 语言函数引用传递值
  • 函数用法
    • Go 语言函数作为实参与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 运行结果
奔驰 品牌的汽车，颜色是黑色,正在鸣笛
宝马 品牌的汽车，颜色是白色,正在行驶

这篇关于go 语言控制台输入和go语言函数的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！