标签：语言 int fmt Println func go 控制台 main 函数

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 运行结果
奔驰 品牌的汽车，颜色是黑色,正在鸣笛
宝马 品牌的汽车，颜色是白色,正在行驶

标签：语言,int,fmt,Println,func,go,控制台,main,函数
来源： https://www.cnblogs.com/zhijiyiyu/p/16056768.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。